[clang] fix transformation of template arguments for concept specializations

[mizvekov]

Summary

See PR50864.

This fixes error caused by substitution failures on template arguments
for concept specializations. With this patch, in such cases, the concept
specialization will evaluate to false instead.

As a bonus, we:

• Remove some memory leak as an std::string was being stored in the AST.
• Remove some duplicate implementation of serialization (as string) of substitution diagnostics for concepts.
• Fix some cases where we would try to take a SFINAE diagnostic without checking if there was one first.

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

[mizvekov]

• Better naming
• Stop casting SmallString to StringRef, use .str() method instead.

clang/include/clang/AST/ASTConcept.h

 #include "llvm/ADT/PointerUnion.h"
 #include "llvm/ADT/SmallVector.h"
 #include <utility>
 
 namespace clang {
 class ConceptDecl;
 class ConceptSpecializationExpr;
 
+struct ConceptSubstitutionDiagnostic {
+  SourceLocation Loc;
+  // FIXME: Store diagnostics semantically and not as prerendered strings.
+  //  Fixing this probably requires serialization of PartialDiagnostic
+  //  objects.
+  StringRef Msg;
+};
+
 /// The result of a constraint satisfaction check, containing the necessary
 /// information to diagnose an unsatisfied constraint.
 class ConstraintSatisfaction : public llvm::FoldingSetNode {
   // The template-like entity that 'owns' the constraint checked here (can be a
   // constrained entity or a concept).
   const NamedDecl *ConstraintOwner = nullptr;
   llvm::SmallVector<TemplateArgument, 4> TemplateArgs;
 
 public:
 
   ConstraintSatisfaction() = default;
 
   ConstraintSatisfaction(const NamedDecl *ConstraintOwner,
                          ArrayRef<TemplateArgument> TemplateArgs) :
       ConstraintOwner(ConstraintOwner), TemplateArgs(TemplateArgs.begin(),
                                                      TemplateArgs.end()) { }
 
-  using SubstitutionDiagnostic = std::pair<SourceLocation, StringRef>;
+  using SubstitutionDiagnostic = ConceptSubstitutionDiagnostic;
   using Detail = llvm::PointerUnion<Expr *, SubstitutionDiagnostic *>;
 
   bool IsSatisfied = false;
 
   /// \brief Pairs of unsatisfied atomic constraint expressions along with the
   /// substituted constraint expr, if the template arguments could be
   /// substituted into them, or a diagnostic if substitution resulted in an
   /// invalid expression.

 };
 
 /// Pairs of unsatisfied atomic constraint expressions along with the
 /// substituted constraint expr, if the template arguments could be
 /// substituted into them, or a diagnostic if substitution resulted in
 /// an invalid expression.
 using UnsatisfiedConstraintRecord =
     std::pair<const Expr *,
-              llvm::PointerUnion<Expr *,
-                                 std::pair<SourceLocation, StringRef> *>>;
+              llvm::PointerUnion<Expr *, ConceptSubstitutionDiagnostic *>>;
 
 /// \brief The result of a constraint satisfaction check, containing the
 /// necessary information to diagnose an unsatisfied constraint.
 ///
 /// This is safe to store in an AST node, as opposed to ConstraintSatisfaction.
 struct ASTConstraintSatisfaction final :
     llvm::TrailingObjects<ASTConstraintSatisfaction,
                           UnsatisfiedConstraintRecord> {

clang/include/clang/AST/ExprConcepts.h

 /// According to C++2a [expr.prim.id]p3 an id-expression that denotes the
 /// specialization of a concept results in a prvalue of type bool.
 class ConceptSpecializationExpr final : public Expr, public ConceptReference,
       private llvm::TrailingObjects<ConceptSpecializationExpr,
                                     TemplateArgument> {
   friend class ASTStmtReader;
   friend TrailingObjects;
 public:
-  using SubstitutionDiagnostic = std::pair<SourceLocation, std::string>;
+  using SubstitutionDiagnostic = ConceptSubstitutionDiagnostic;
 
 protected:
   /// \brief The number of template arguments in the tail-allocated list of
   /// converted template arguments.
   unsigned NumTemplateArgs;
 
   /// \brief Information about the satisfaction of the named concept with the
   /// given arguments. If this expression is value dependent, this is to be
private:
   const RequirementKind Kind;
   // FIXME: use RequirementDependence to model dependence?
   bool Dependent : 1;
   bool ContainsUnexpandedParameterPack : 1;
   bool Satisfied : 1;
 public:
   struct SubstitutionDiagnostic {
     StringRef SubstitutedEntity;
-    // FIXME: Store diagnostics semantically and not as prerendered strings.
-    //  Fixing this probably requires serialization of PartialDiagnostic
-    //  objects.
-    SourceLocation DiagLoc;
-    StringRef DiagMessage;
+    ConceptSubstitutionDiagnostic Diag;
   };
 
   Requirement(RequirementKind Kind, bool IsDependent,
               bool ContainsUnexpandedParameterPack, bool IsSatisfied = true) :
       Kind(Kind), Dependent(IsDependent),
       ContainsUnexpandedParameterPack(ContainsUnexpandedParameterPack),
       Satisfied(IsSatisfied) {}
 

clang/include/clang/Basic/DiagnosticSemaKinds.td

def err_non_constant_constraint_expression : Error<
   "substitution into constraint expression resulted in a non-constant "
   "expression">;
 def err_non_bool_atomic_constraint : Error<
   "atomic constraint must be of type 'bool' (found %0)">;
 def err_template_arg_list_constraints_not_satisfied : Error<
   "constraints not satisfied for %select{class template|function template|variable template|alias template|"
   "template template parameter|template}0 %1%2">;
 def note_substituted_constraint_expr_is_ill_formed : Note<
-  "because substituted constraint expression is ill-formed%0">;
+  "because substituted constraint expression is ill-formed%select{: %1|}0">;
 def note_atomic_constraint_evaluated_to_false : Note<
   "%select{and|because}0 '%1' evaluated to false">;
 def note_concept_specialization_constraint_evaluated_to_false : Note<
   "%select{and|because}0 '%1' evaluated to false">;
 def note_single_arg_concept_specialization_constraint_evaluated_to_false : Note<
   "%select{and|because}0 %1 does not satisfy %2">;
 def note_atomic_constraint_evaluated_to_false_elaborated : Note<
   "%select{and|because}0 '%1' (%2 %3 %4) evaluated to false">;

clang/include/clang/Sema/Sema.h

public:
 
   /// If D1 was not at least as constrained as D2, but would've been if a pair
   /// of atomic constraints involved had been declared in a concept and not
   /// repeated in two separate places in code.
   /// \returns true if such a diagnostic was emitted, false otherwise.
   bool MaybeEmitAmbiguousAtomicConstraintsDiagnostic(NamedDecl *D1,
       ArrayRef<const Expr *> AC1, NamedDecl *D2, ArrayRef<const Expr *> AC2);
 
+  ConceptSubstitutionDiagnostic
+  getConceptSubstitutionDiagnostic(sema::TemplateDeductionInfo &TDI);
+
   /// \brief Check whether the given list of constraint expressions are
   /// satisfied (as if in a 'conjunction') given template arguments.
   /// \param Template the template-like entity that triggered the constraints
   /// check (either a concept or a constrained entity).
   /// \param ConstraintExprs a list of constraint expressions, treated as if
   /// they were 'AND'ed together.
   /// \param TemplateArgs the list of template arguments to substitute into the
   /// constraint expression.

clang/lib/AST/ASTConcept.cpp

for (unsigned I = 0; I < NumRecords; ++I) {
     auto &Detail = Satisfaction.Details[I];
     if (Detail.second.is<Expr *>())
       new (getTrailingObjects<UnsatisfiedConstraintRecord>() + I)
          UnsatisfiedConstraintRecord{Detail.first,
                                      UnsatisfiedConstraintRecord::second_type(
                                          Detail.second.get<Expr *>())};
     else {
       auto &SubstitutionDiagnostic =
-          *Detail.second.get<std::pair<SourceLocation, StringRef> *>();
-      unsigned MessageSize = SubstitutionDiagnostic.second.size();
-      char *Mem = new (C) char[MessageSize];
-      memcpy(Mem, SubstitutionDiagnostic.second.data(), MessageSize);
-      auto *NewSubstDiag = new (C) std::pair<SourceLocation, StringRef>(
-          SubstitutionDiagnostic.first, StringRef(Mem, MessageSize));
+          *Detail.second.get<ConceptSubstitutionDiagnostic *>();
+      auto *NewSubstDiag = new (C) ConceptSubstitutionDiagnostic{
+          SubstitutionDiagnostic.Loc,
+          SubstitutionDiagnostic.Msg.copy(C.getAllocator())};
       new (getTrailingObjects<UnsatisfiedConstraintRecord>() + I)
          UnsatisfiedConstraintRecord{Detail.first,
                                      UnsatisfiedConstraintRecord::second_type(
                                          NewSubstDiag)};
     }
   }
 }
 

clang/lib/Sema/SemaConcept.cpp

if (!Context.hasSameUnqualifiedType(Type, Context.BoolTy)) {
     return false;
   }
 
   if (PossibleNonPrimary)
       *PossibleNonPrimary = false;
   return true;
 }
 
+// FIXME: Concepts: This is an unfortunate consequence of there
+//  being no serialization code for PartialDiagnostics and the fact
+//  that serializing them would likely take a lot more storage than
+//  just storing them as strings. We would still like, in the
+//  future, to serialize the proper PartialDiagnostic as serializing
+//  it as a string defeats the purpose of the diagnostic mechanism.
+ConceptSubstitutionDiagnostic
+Sema::getConceptSubstitutionDiagnostic(TemplateDeductionInfo &TDI) {
+  if (!TDI.hasSFINAEDiagnostic())
+    return {TDI.getLocation(), StringRef()};
+
+  PartialDiagnosticAt SubstDiag{SourceLocation(),
+                                PartialDiagnostic::NullDiagnostic()};
+  TDI.takeSFINAEDiagnostic(SubstDiag);
+  SmallString<128> DiagString;
+  SubstDiag.second.EmitToString(getDiagnostics(), DiagString);
+  return {SubstDiag.first, DiagString.str().copy(Context.getAllocator())};
+}
+
 template <typename AtomicEvaluator>
 static bool
 calculateConstraintSatisfaction(Sema &S, const Expr *ConstraintExpr,
                                 ConstraintSatisfaction &Satisfaction,
                                 AtomicEvaluator &&Evaluator) {
   ConstraintExpr = ConstraintExpr->IgnoreParenImpCasts();
 
   if (LogicalBinOp BO = ConstraintExpr) {
return calculateConstraintSatisfaction(
                                               MLTAL);
           // Substitution might have stripped off a contextual conversion to
           // bool if this is the operand of an '&&' or '||'. For example, we
           // might lose an lvalue-to-rvalue conversion here. If so, put it back
           // before we try to evaluate.
           if (!SubstitutedExpression.isInvalid())
             SubstitutedExpression =
                 S.PerformContextuallyConvertToBool(SubstitutedExpression.get());
-          if (SubstitutedExpression.isInvalid() || Trap.hasErrorOccurred()) {
+          if (Trap.hasErrorOccurred()) {
             // C++2a [temp.constr.atomic]p1
             //   ...If substitution results in an invalid type or expression, the
             //   constraint is not satisfied.
-            if (!Trap.hasErrorOccurred())
-              // A non-SFINAE error has occured as a result of this
-              // substitution.
-              return ExprError();
-
-            PartialDiagnosticAt SubstDiag{SourceLocation(),
-                                          PartialDiagnostic::NullDiagnostic()};
-            Info.takeSFINAEDiagnostic(SubstDiag);
-            // FIXME: Concepts: This is an unfortunate consequence of there
-            //  being no serialization code for PartialDiagnostics and the fact
-            //  that serializing them would likely take a lot more storage than
-            //  just storing them as strings. We would still like, in the
-            //  future, to serialize the proper PartialDiagnostic as serializing
-            //  it as a string defeats the purpose of the diagnostic mechanism.
-            SmallString<128> DiagString;
-            DiagString = ": ";
-            SubstDiag.second.EmitToString(S.getDiagnostics(), DiagString);
-            unsigned MessageSize = DiagString.size();
-            char *Mem = new (S.Context) char[MessageSize];
-            memcpy(Mem, DiagString.c_str(), MessageSize);
             Satisfaction.Details.emplace_back(
                 AtomicExpr,
-                new (S.Context) ConstraintSatisfaction::SubstitutionDiagnostic{
-                        SubstDiag.first, StringRef(Mem, MessageSize)});
+                new (S.Context) ConstraintSatisfaction::SubstitutionDiagnostic(
+                    S.getConceptSubstitutionDiagnostic(Info)));
             Satisfaction.IsSatisfied = false;
             return ExprEmpty();
           }
+          if (SubstitutedExpression.isInvalid())
+            // A non-SFINAE error has occured as a result of this
+            // substitution.
+            return ExprError();
         }
 
         if (!S.CheckConstraintExpression(SubstitutedExpression.get()))
           return ExprError();
 
         return SubstitutedExpression;
       });
 }
static void diagnoseUnsatisfiedRequirement(Sema &S,
   assert(!Req->isSatisfied()
          && "Diagnose() can only be used on an unsatisfied requirement");
   switch (Req->getSatisfactionStatus()) {
     case concepts::ExprRequirement::SS_Dependent:
       llvm_unreachable("Diagnosing a dependent requirement");
       break;
     case concepts::ExprRequirement::SS_ExprSubstitutionFailure: {
       auto *SubstDiag = Req->getExprSubstitutionDiagnostic();
-      if (!SubstDiag->DiagMessage.empty())
-        S.Diag(SubstDiag->DiagLoc,
+      if (!SubstDiag->Diag.Msg.empty())
+        S.Diag(SubstDiag->Diag.Loc,
                diag::note_expr_requirement_expr_substitution_error)
-               << (int)First << SubstDiag->SubstitutedEntity
-               << SubstDiag->DiagMessage;
+            << SubstDiag->Diag.Msg;
       else
-        S.Diag(SubstDiag->DiagLoc,
+        S.Diag(SubstDiag->Diag.Loc,
                diag::note_expr_requirement_expr_unknown_substitution_error)
             << (int)First << SubstDiag->SubstitutedEntity;
       break;
     }
     case concepts::ExprRequirement::SS_NoexceptNotMet:
       S.Diag(Req->getNoexceptLoc(),
              diag::note_expr_requirement_noexcept_not_met)
           << (int)First << Req->getExpr();
       break;
     case concepts::ExprRequirement::SS_TypeRequirementSubstitutionFailure: {
       auto *SubstDiag =
           Req->getReturnTypeRequirement().getSubstitutionDiagnostic();
-      if (!SubstDiag->DiagMessage.empty())
-        S.Diag(SubstDiag->DiagLoc,
+      if (!SubstDiag->Diag.Msg.empty())
+        S.Diag(SubstDiag->Diag.Loc,
                diag::note_expr_requirement_type_requirement_substitution_error)
             << (int)First << SubstDiag->SubstitutedEntity
-            << SubstDiag->DiagMessage;
+            << SubstDiag->Diag.Msg;
       else
-        S.Diag(SubstDiag->DiagLoc,
-               diag::note_expr_requirement_type_requirement_unknown_substitution_error)
+        S.Diag(
+            SubstDiag->Diag.Loc,
+            diag::
+                note_expr_requirement_type_requirement_unknown_substitution_error)
             << (int)First << SubstDiag->SubstitutedEntity;
       break;
     }
     case concepts::ExprRequirement::SS_ConstraintsNotSatisfied: {
       ConceptSpecializationExpr *ConstraintExpr =
           Req->getReturnTypeRequirementSubstitutedConstraintExpr();
       if (ConstraintExpr->getTemplateArgsAsWritten()->NumTemplateArgs == 1) {
         // A simple case - expr type is the type being constrained and the concept
static void diagnoseUnsatisfiedRequirement(Sema &S,
   assert(!Req->isSatisfied()
          && "Diagnose() can only be used on an unsatisfied requirement");
   switch (Req->getSatisfactionStatus()) {
   case concepts::TypeRequirement::SS_Dependent:
     llvm_unreachable("Diagnosing a dependent requirement");
     return;
   case concepts::TypeRequirement::SS_SubstitutionFailure: {
     auto *SubstDiag = Req->getSubstitutionDiagnostic();
-    if (!SubstDiag->DiagMessage.empty())
-      S.Diag(SubstDiag->DiagLoc,
-             diag::note_type_requirement_substitution_error) << (int)First
-          << SubstDiag->SubstitutedEntity << SubstDiag->DiagMessage;
+    if (!SubstDiag->Diag.Msg.empty())
+      S.Diag(SubstDiag->Diag.Loc,
+             diag::note_type_requirement_substitution_error)
+          << (int)First << SubstDiag->SubstitutedEntity << SubstDiag->Diag.Msg;
     else
-      S.Diag(SubstDiag->DiagLoc,
+      S.Diag(SubstDiag->Diag.Loc,
              diag::note_type_requirement_unknown_substitution_error)
           << (int)First << SubstDiag->SubstitutedEntity;
     return;
   }
   default:
     llvm_unreachable("Unknown satisfaction status");
     return;
   }
 }
 
 static void diagnoseUnsatisfiedRequirement(Sema &S,
                                            concepts::NestedRequirement *Req,
                                            bool First) {
   if (Req->isSubstitutionFailure()) {
     concepts::Requirement::SubstitutionDiagnostic *SubstDiag =
         Req->getSubstitutionDiagnostic();
-    if (!SubstDiag->DiagMessage.empty())
-      S.Diag(SubstDiag->DiagLoc,
+    if (!SubstDiag->Diag.Msg.empty())
+      S.Diag(SubstDiag->Diag.Loc,
              diag::note_nested_requirement_substitution_error)
-             << (int)First << SubstDiag->SubstitutedEntity
-             << SubstDiag->DiagMessage;
+          << (int)First << SubstDiag->SubstitutedEntity << SubstDiag->Diag.Msg;
     else
-      S.Diag(SubstDiag->DiagLoc,
+      S.Diag(SubstDiag->Diag.Loc,
              diag::note_nested_requirement_unknown_substitution_error)
           << (int)First << SubstDiag->SubstitutedEntity;
     return;
   }
   S.DiagnoseUnsatisfiedConstraint(Req->getConstraintSatisfaction(), First);
 }
 
 

 }
 
 template<typename SubstitutionDiagnostic>
 static void diagnoseUnsatisfiedConstraintExpr(
     Sema &S, const Expr *E,
     const llvm::PointerUnion<Expr *, SubstitutionDiagnostic *> &Record,
     bool First = true) {
   if (auto *Diag = Record.template dyn_cast<SubstitutionDiagnostic *>()){
-    S.Diag(Diag->first, diag::note_substituted_constraint_expr_is_ill_formed)
-        << Diag->second;
+    S.Diag(Diag->Loc, diag::note_substituted_constraint_expr_is_ill_formed)
+        << Diag->Msg.empty() << Diag->Msg;
     return;
   }
 
   diagnoseWellFormedUnsatisfiedConstraintExpr(S,
       Record.template get<Expr *>(), First);
 }
 
 void

clang/lib/Sema/SemaTemplateInstantiate.cpp

public:
 
     concepts::TypeRequirement *
     TransformTypeRequirement(concepts::TypeRequirement *Req);
     concepts::ExprRequirement *
     TransformExprRequirement(concepts::ExprRequirement *Req);
     concepts::NestedRequirement *
     TransformNestedRequirement(concepts::NestedRequirement *Req);
 
+    ExprResult TransformConceptSpecializationExpr(ConceptSpecializationExpr *E);
+
   private:
     ExprResult transformNonTypeTemplateParmRef(NonTypeTemplateParmDecl *parm,
                                                SourceLocation loc,
                                                TemplateArgument arg);
   };
 }
 
 bool TemplateInstantiator::AlreadyTransformed(QualType T) {
SubstTemplateTypeParmTypeLoc NewTL
     = TLB.push<SubstTemplateTypeParmTypeLoc>(Result);
   NewTL.setNameLoc(TL.getNameLoc());
   return Result;
 }
 
 template<typename EntityPrinter>
 static concepts::Requirement::SubstitutionDiagnostic *
 createSubstDiag(Sema &S, TemplateDeductionInfo &Info, EntityPrinter Printer) {
-  SmallString<128> Message;
-  SourceLocation ErrorLoc;
-  if (Info.hasSFINAEDiagnostic()) {
-    PartialDiagnosticAt PDA(SourceLocation(),
-                            PartialDiagnostic::NullDiagnostic{});
-    Info.takeSFINAEDiagnostic(PDA);
-    PDA.second.EmitToString(S.getDiagnostics(), Message);
-    ErrorLoc = PDA.first;
-  } else {
-    ErrorLoc = Info.getLocation();
-  }
-  char *MessageBuf = new (S.Context) char[Message.size()];
-  std::copy(Message.begin(), Message.end(), MessageBuf);
   SmallString<128> Entity;
   llvm::raw_svector_ostream OS(Entity);
   Printer(OS);
-  char *EntityBuf = new (S.Context) char[Entity.size()];
-  std::copy(Entity.begin(), Entity.end(), EntityBuf);
   return new (S.Context) concepts::Requirement::SubstitutionDiagnostic{
-      StringRef(EntityBuf, Entity.size()), ErrorLoc,
-      StringRef(MessageBuf, Message.size())};
+      Entity.str().copy(S.Context.getAllocator()),
+      S.getConceptSubstitutionDiagnostic(Info)};
 }
 
 concepts::TypeRequirement *
 TemplateInstantiator::TransformTypeRequirement(concepts::TypeRequirement *Req) {
   if (!Req->isDependent() && !AlwaysRebuild())
     return Req;
   if (Req->isSubstitutionFailure()) {
     if (AlwaysRebuild())
if (TransConstraint.isInvalid() || Trap.hasErrorOccurred())
           [&] (llvm::raw_ostream& OS) {
               Req->getConstraintExpr()->printPretty(OS, nullptr,
                                                     SemaRef.getPrintingPolicy());
           }));
   }
   return RebuildNestedRequirement(TransConstraint.get());
 }
 
+ExprResult TemplateInstantiator::TransformConceptSpecializationExpr(
+    ConceptSpecializationExpr *E) {
+
+  Sema::SFINAETrap Trap(SemaRef);
+  TemplateDeductionInfo Info(E->getTemplateKWLoc());
+  Sema::InstantiatingTemplate Inst(
+      SemaRef, E->getBeginLoc(),
+      Sema::InstantiatingTemplate::ConstraintSubstitution{},
+      E->getNamedConcept(), Info, E->getSourceRange());
+  if (Inst.isInvalid())
+    return ExprError();
+
+  CXXScopeSpec SS;
+  SS.Adopt(E->getNestedNameSpecifierLoc());
+
+  const ASTTemplateArgumentListInfo *Old = E->getTemplateArgsAsWritten();
+  TemplateArgumentListInfo TransArgs(Old->LAngleLoc, Old->RAngleLoc);
+  if (TransformTemplateArguments(Old->getTemplateArgs(), Old->NumTemplateArgs,
+                                 TransArgs) ||
+      Trap.hasErrorOccurred()) {
+    ConstraintSatisfaction Satisfaction;
+    Satisfaction.Details.emplace_back(
+        nullptr,
+        new (SemaRef.Context) ConstraintSatisfaction::SubstitutionDiagnostic(
+            SemaRef.getConceptSubstitutionDiagnostic(Info)));
+    return ConceptSpecializationExpr::Create(
+        SemaRef.Context,
+        SS.isSet() ? SS.getWithLocInContext(SemaRef.Context)
+                   : NestedNameSpecifierLoc{},
+        E->getTemplateKWLoc(), E->getConceptNameInfo(), E->getFoundDecl(),
+        E->getNamedConcept(), Old, ArrayRef<TemplateArgument>{}, &Satisfaction);
+  }
+
+  ExprResult Result = SemaRef.CheckConceptTemplateId(
+      SS, E->getTemplateKWLoc(), E->getConceptNameInfo(), E->getFoundDecl(),
+      E->getNamedConcept(), &TransArgs);
+  if (Result.isInvalid())
+    return ExprError();
+  return Result;
+}
 
 /// Perform substitution on the type T with a given set of template
 /// arguments.
 ///
 /// This routine substitutes the given template arguments into the
 /// type T and produces the instantiated type.
 ///
 /// \param T the type into which the template arguments will be

clang/lib/Sema/TreeTransform.h

   /// Subclasses may override this routine to provide different behavior.
   ExprResult RebuildSourceLocExpr(SourceLocExpr::IdentKind Kind,
                                   SourceLocation BuiltinLoc,
                                   SourceLocation RPLoc,
                                   DeclContext *ParentContext) {
     return getSema().BuildSourceLocExpr(Kind, BuiltinLoc, RPLoc, ParentContext);
   }
 
-  /// Build a new Objective-C boxed expression.
-  ///
-  /// By default, performs semantic analysis to build the new expression.
-  /// Subclasses may override this routine to provide different behavior.
-  ExprResult RebuildConceptSpecializationExpr(NestedNameSpecifierLoc NNS,
-      SourceLocation TemplateKWLoc, DeclarationNameInfo ConceptNameInfo,
-      NamedDecl *FoundDecl, ConceptDecl *NamedConcept,
-      TemplateArgumentListInfo *TALI) {
-    CXXScopeSpec SS;
-    SS.Adopt(NNS);
-    ExprResult Result = getSema().CheckConceptTemplateId(SS, TemplateKWLoc,
-                                                         ConceptNameInfo,
-                                                         FoundDecl,
-                                                         NamedConcept, TALI);
-    if (Result.isInvalid())
-      return ExprError();
-    return Result;
-  }
-
   /// \brief Build a new requires expression.
   ///
   /// By default, performs semantic analysis to build the new expression.
   /// Subclasses may override this routine to provide different behavior.
   ExprResult RebuildRequiresExpr(SourceLocation RequiresKWLoc,
                                  RequiresExprBodyDecl *Body,
                                  ArrayRef<ParmVarDecl *> LocalParameters,
                                  ArrayRef<concepts::Requirement *> Requirements,
TreeTransform<Derived>::TransformTypeTraitExpr(TypeTraitExpr *E) {
 
   if (!getDerived().AlwaysRebuild() && !ArgChanged)
     return E;
 
   return getDerived().RebuildTypeTrait(E->getTrait(), E->getBeginLoc(), Args,
                                        E->getEndLoc());
 }
 
-template<typename Derived>
-ExprResult
-TreeTransform<Derived>::TransformConceptSpecializationExpr(
-                                                 ConceptSpecializationExpr *E) {
-  const ASTTemplateArgumentListInfo *Old = E->getTemplateArgsAsWritten();
-  TemplateArgumentListInfo TransArgs(Old->LAngleLoc, Old->RAngleLoc);
-  if (getDerived().TransformTemplateArguments(Old->getTemplateArgs(),
-                                              Old->NumTemplateArgs, TransArgs))
-    return ExprError();
-
-  return getDerived().RebuildConceptSpecializationExpr(
-      E->getNestedNameSpecifierLoc(), E->getTemplateKWLoc(),
-      E->getConceptNameInfo(), E->getFoundDecl(), E->getNamedConcept(),
-      &TransArgs);
+template <typename Derived>
+ExprResult TreeTransform<Derived>::TransformConceptSpecializationExpr(
+  return E;
 }
 
 template<typename Derived>
 ExprResult
 TreeTransform<Derived>::TransformRequiresExpr(RequiresExpr *E) {
   SmallVector<ParmVarDecl*, 4> TransParams;
   SmallVector<QualType, 4> TransParamTypes;
   Sema::ExtParameterInfoBuilder ExtParamInfos;

clang/lib/Serialization/ASTWriterStmt.cpp

if (!Satisfaction.IsSatisfied) {
     Record.push_back(Satisfaction.NumRecords);
     for (const auto &DetailRecord : Satisfaction) {
       Record.AddStmt(const_cast<Expr *>(DetailRecord.first));
       auto *E = DetailRecord.second.dyn_cast<Expr *>();
       Record.push_back(E == nullptr);
       if (E)
         Record.AddStmt(E);
       else {
-        auto *Diag = DetailRecord.second.get<std::pair<SourceLocation,
-                                                       StringRef> *>();
-        Record.AddSourceLocation(Diag->first);
-        Record.AddString(Diag->second);
+        auto *Diag = DetailRecord.second.get<ConceptSubstitutionDiagnostic *>();
+        Record.AddSourceLocation(Diag->Loc);
+        Record.AddString(Diag->Msg);
       }
     }
   }
 }
 
 static void
 addSubstitutionDiagnostic(
     ASTRecordWriter &Record,
     const concepts::Requirement::SubstitutionDiagnostic *D) {
   Record.AddString(D->SubstitutedEntity);
-  Record.AddSourceLocation(D->DiagLoc);
-  Record.AddString(D->DiagMessage);
+  Record.AddSourceLocation(D->Diag.Loc);
+  Record.AddString(D->Diag.Msg);
 }
 
 void ASTStmtWriter::VisitConceptSpecializationExpr(
         ConceptSpecializationExpr *E) {
   VisitExpr(E);
   ArrayRef<TemplateArgument> TemplateArgs = E->getTemplateArguments();
   Record.push_back(TemplateArgs.size());
   Record.AddNestedNameSpecifierLoc(E->getNestedNameSpecifierLoc());

clang/test/SemaTemplate/concepts.cpp

 }
 
 namespace PR50561 {
   template<typename> concept C = false;
   template<typename T, typename U> void f(T, U);
   template<C T, typename U> void f(T, U) = delete;
   void g() { f(0, 0); }
 }
+
+namespace PR50864 {
+  template <class T> concept Valid = T::valid; // expected-note {{evaluated to false}}
+  template <class T> struct A {
+    template <class U> void f(U) requires Valid<typename T::type>;
+    // expected-note@-1 {{candidate template ignored: constraints not satisfied [with U = int]}}
+    // expected-note@-2 {{because 'typename T::type' does not satisfy 'Valid'}}
+    // expected-note@-3 {{because substituted constraint expression is ill-formed: type 'int' cannot be used prior to '::' because it has no members}}
+    template <class U> void f(U) requires Valid<T>;
+    // expected-note@-1 {{candidate template ignored: constraints not satisfied [with U = int]}}
+    // expected-note@-2 {{does not satisfy 'Valid'}}
+  };
+
+  template<bool V> struct X { static constexpr bool valid = V; };
+
+  struct T1 : X<false> {};
+  void t1() { A<T1>().f(1); } // expected-error {{no matching member function for call to 'f'}}
+
+  struct T2 : X<true> {};
+  void t2() { A<T2>().f(1); }
+}