[Concepts] Delayed Constraint Substitution

[saar.raz]

Summary

Constraint expressions will now not be substituted into when instantiating constrained declarations, and all substitution will be delayed to when satisfaction or subsumption have to be determined. Also, when explicitly instantiating a class template specialization, members whose constraints are not satisfied will not be instantiated. Depends on D50360.

[saar.raz]

Removed support for outdated grammar (adjusting to previous patches)

[saar.raz]

Only include template parameters that occur in the atomic constraint in the parameter mapping

[saar.raz]

Do not instantiate lambda expression trailing requires clause

[rsmith]

I wonder if there's a cleaner way to model this:

Suppose we add a new Expr subclass for an expression with delayed template argument substitution, which would capture a list of TemplateArguments and an inner Expr* into which those template arguments have not yet been substituted. Then when we transform a trailing requires-clause, we can wrap it suitably with that expression node, and similarly when we transform a TypeConstraint we can wrap the immediately-declared constraint in the partial substitution wrapper.

We'd need to teach normalization to pick up the wrapper and turn it into a parameter mapping, and we'd need to teach satisfaction checking to actually substitute that partially-substituted wrapper, but I think the result would be a bit simpler and wouldn't need us to carefully keep track of whether each individual constraint is substituted or not. What do you think?

include/clang/AST/DeclTemplate.h

69–71

Please can you introduce a typedef or wrapper type for this? Maybe a struct TemplateHeadConstraints or similar?

95–97

Consider passing the union type (whatever it's called) here instead of having an Expr* argument and a TemplateParameterList* argument, at least one of which must be null.

1176

Is it feasible to tail-allocate the pointer? (At least in the case where there is no type-constraint, it'd be nice to avoid allocating storage for it; allocating it unconditionally along with the TypeConstraint seems good enough to me.)

include/clang/AST/DeclTemplate.h

llvm::PointerUnion3<TemplateTypeParmDecl *, NonTypeTemplateParmDecl *,
                         TemplateTemplateParmDecl *>;
 
 NamedDecl *getAsNamedDecl(TemplateParameter P);
 
 /// Stores a list of template parameters for a TemplateDecl and its
 /// derived classes.
 class TemplateParameterList final
     : private llvm::TrailingObjects<TemplateParameterList, NamedDecl *,
-                                    Expr *> {
+                                  llvm::PointerUnion<Expr *,
+                                                     TemplateParameterList *>> {
   /// The location of the 'template' keyword.
   SourceLocation TemplateLoc;
 
   /// The locations of the '<' and '>' angle brackets.
   SourceLocation LAngleLoc, RAngleLoc;
 
   /// The number of template parameters in this template
   /// parameter list.
   unsigned NumParams : 30;
 
   /// Whether this template parameter list contains an unexpanded parameter
   /// pack.
   unsigned ContainsUnexpandedParameterPack : 1;
 
   /// Whether this template parameter list has a requires clause.
   unsigned HasRequiresClause : 1;
 
   /// Whether any of the template parameters has constrained-parameter
   /// constraint-expression.
   unsigned HasConstrainedParameters : 1;
 
 protected:
   TemplateParameterList(const ASTContext& C, SourceLocation TemplateLoc,
                         SourceLocation LAngleLoc, ArrayRef<NamedDecl *> Params,
-                        SourceLocation RAngleLoc, Expr *RequiresClause);
+                        SourceLocation RAngleLoc, Expr *RequiresClause,
+                        TemplateParameterList *InheritedConstraints);
 
   size_t numTrailingObjects(OverloadToken<NamedDecl *>) const {
     return NumParams;
   }
 
-  size_t numTrailingObjects(OverloadToken<Expr *>) const {
+  size_t numTrailingObjects(
+      OverloadToken<llvm::PointerUnion<Expr *, TemplateParameterList *>>) const{
     return HasRequiresClause ? 1 : 0;
   }
 
 public:
   template <size_t N, bool HasRequiresClause>
   friend class FixedSizeTemplateParameterListStorage;
   friend TrailingObjects;
 
   static TemplateParameterList *Create(const ASTContext &C,
-                                       SourceLocation TemplateLoc,
-                                       SourceLocation LAngleLoc,
-                                       ArrayRef<NamedDecl *> Params,
-                                       SourceLocation RAngleLoc,
-                                       Expr *RequiresClause);
+      SourceLocation TemplateLoc, SourceLocation LAngleLoc,
+      ArrayRef<NamedDecl *> Params, SourceLocation RAngleLoc,
+      Expr *RequiresClause,
+      TemplateParameterList *InheritedConstraints = nullptr);
 
   /// Iterates through the template parameters in this list.
   using iterator = NamedDecl **;
 
   /// Iterates through the template parameters in this list.
   using const_iterator = NamedDecl * const *;
 
   iterator begin() { return getTrailingObjects<NamedDecl *>(); }
public:
   /// Determine whether this template parameter list contains a parameter pack.
   bool hasParameterPack() const {
     for (const NamedDecl *P : asArray())
       if (P->isParameterPack())
         return true;
     return false;
   }
 
+  SourceLocation getTemplateLoc() const { return TemplateLoc; }
+  SourceLocation getLAngleLoc() const { return LAngleLoc; }
+  SourceLocation getRAngleLoc() const { return RAngleLoc; }
+
+  SourceRange getSourceRange() const LLVM_READONLY {
+    return SourceRange(TemplateLoc, RAngleLoc);
+  }
+
   /// The constraint-expression of the associated requires-clause.
   Expr *getRequiresClause() {
-    return HasRequiresClause ? getTrailingObjects<Expr *>()[0] : nullptr;
+    if (!HasRequiresClause)
+      return nullptr;
+    const auto &P = *getTrailingObjects<llvm::PointerUnion<Expr *,
+                                                    TemplateParameterList *>>();
+    if (auto *I = P.dyn_cast<TemplateParameterList *>())
+      return I->getRequiresClause();
+    return P.get<Expr *>();
   }
 
   /// The constraint-expression of the associated requires-clause.
   const Expr *getRequiresClause() const {
-    return HasRequiresClause ? getTrailingObjects<Expr *>()[0] : nullptr;
+    if (!HasRequiresClause)
+      return nullptr;
+    const auto &P = *getTrailingObjects<llvm::PointerUnion<Expr *,
+                                                    TemplateParameterList *>>();
+    if (auto *I = P.dyn_cast<TemplateParameterList *>())
+      return I->getRequiresClause();
+    return P.get<Expr *>();
+  }
+
+  void setRequiresClause(Expr *RC) {
+    assert(HasRequiresClause &&
+           "Can only set requires clause on TPLs that were originally created "
+           "with one.");
+    *getTrailingObjects<llvm::PointerUnion<Expr *,
+                                           TemplateParameterList *>>() = RC;
+  }
+
+  void setInheritedConstraints(TemplateParameterList *InheritedConstraints) {
+    assert(HasRequiresClause &&
+           "Can only setInheritedConstraints when there is already a requires "
+           "clause");
+    auto &P = *getTrailingObjects<llvm::PointerUnion<Expr *,
+                                                    TemplateParameterList *>>();
+    P = InheritedConstraints;
+  }
+
+  TemplateParameterList *getInheritedConstraints() {
+    return getTrailingObjects<llvm::PointerUnion<Expr *,
+                                                 TemplateParameterList *>>()
+        ->get<TemplateParameterList *>();
+  }
+
+  bool inheritsConstraints() const {
+    return getTrailingObjects<llvm::PointerUnion<Expr *,
+                                                 TemplateParameterList *>>()
+        ->is<TemplateParameterList *>();
   }
 
   /// \brief All associated constraints derived from this template parameter
   /// list, including the requires clause and any constraints derived from
   /// constrained-parameters.
   ///
   /// The constraints in the resulting list are to be treated as if in a
   /// conjunction ("and").
   llvm::SmallVector<const Expr *, 3> getAssociatedConstraints() const;
 
+  /// \brief Whether there are associated constraints in this template parameter
+  /// list or in any of its parameters.
   bool hasAssociatedConstraints() const;
 
-  SourceLocation getTemplateLoc() const { return TemplateLoc; }
-  SourceLocation getLAngleLoc() const { return LAngleLoc; }
-  SourceLocation getRAngleLoc() const { return RAngleLoc; }
-
-  SourceRange getSourceRange() const LLVM_READONLY {
-    return SourceRange(TemplateLoc, RAngleLoc);
-  }
-
 public:
   // FIXME: workaround for MSVC 2013; remove when no longer needed
   using FixedSizeStorageOwner = TrailingObjects::FixedSizeStorageOwner;
 };
 
 /// Stores a list of template parameters and the associated
 /// requires-clause (if any) for a TemplateDecl and its derived classes.
 /// Suitable for creating on the stack.
 template <size_t N, bool HasRequiresClause>
 class FixedSizeTemplateParameterListStorage
     : public TemplateParameterList::FixedSizeStorageOwner {
   typename TemplateParameterList::FixedSizeStorage<
-      NamedDecl *, Expr *>::with_counts<
-      N, HasRequiresClause ? 1u : 0u
-      >::type storage;
+      NamedDecl *, llvm::PointerUnion<Expr *, TemplateParameterList *>>::
+      with_counts<N, HasRequiresClause ? 1u : 0u>::type storage;
 
 public:
   FixedSizeTemplateParameterListStorage(const ASTContext &C,
                                         SourceLocation TemplateLoc,
                                         SourceLocation LAngleLoc,
                                         ArrayRef<NamedDecl *> Params,
                                         SourceLocation RAngleLoc,
-                                        Expr *RequiresClause)
+                                        Expr *RequiresClause,
+                                    TemplateParameterList *InheritedConstraints)
       : FixedSizeStorageOwner(
             (assert(N == Params.size()),
-             assert(HasRequiresClause == (RequiresClause != nullptr)),
+             assert(HasRequiresClause == (RequiresClause != nullptr
+                    || (InheritedConstraints != nullptr
+                        && InheritedConstraints->HasRequiresClause))),
              new (static_cast<void *>(&storage)) TemplateParameterList(C,
-                 TemplateLoc, LAngleLoc, Params, RAngleLoc, RequiresClause))) {}
+                 TemplateLoc, LAngleLoc, Params, RAngleLoc, RequiresClause,
+                 InheritedConstraints))) {}
 };
 
 /// A template argument list.
 class TemplateArgumentList final
     : private llvm::TrailingObjects<TemplateArgumentList, TemplateArgument> {
   /// The template argument list.
   const TemplateArgument *Arguments;
 
public:
   friend class ASTDeclReader;
   friend class ASTDeclWriter;
 
   /// Get the list of template parameters
   TemplateParameterList *getTemplateParameters() const {
     return TemplateParams;
   }
 
-  /// \brief Get the total constraint-expression associated with this template,
-  /// including constraint-expressions derived from the requires-clause,
-  /// trailing requires-clause (for functions and methods) and constrained
-  /// template parameters.
-  llvm::SmallVector<const Expr *, 3> getAssociatedConstraints() const;
-
-  bool hasAssociatedConstraints() const;
-
   /// Get the underlying, templated declaration.
   NamedDecl *getTemplatedDecl() const { return TemplatedDecl; }
 
   // Implement isa/cast/dyncast/etc.
   static bool classof(const Decl *D) { return classofKind(D->getKind()); }
 
   static bool classofKind(Kind K) {
     return K >= firstTemplate && K <= lastTemplate;
   }
 
   SourceRange getSourceRange() const override LLVM_READONLY {
     return SourceRange(getTemplateParameters()->getTemplateLoc(),
                        TemplatedDecl->getSourceRange().getEnd());
   }
 
+  /// \brief Get the total constraint-expression associated with this template,
+  /// including constraint-expressions derived from the requires-clause,
+  /// trailing requires-clause (for functions and methods) and constrained
+  /// template parameters.
+  llvm::SmallVector<const Expr *, 3> getAssociatedConstraints() const;
+
+  bool hasAssociatedConstraints() const;
+
 protected:
   NamedDecl *TemplatedDecl;
   TemplateParameterList *TemplateParams;
 
   void setTemplateParameters(TemplateParameterList *TParams) {
     TemplateParams = TParams;
   }
 
class TemplateTypeParmDecl : public TypeDecl {
   bool Typename : 1;
 
   /// The default template argument, if any.
   using DefArgStorage =
       DefaultArgStorage<TemplateTypeParmDecl, TypeSourceInfo *>;
   DefArgStorage DefaultArgument;
 
   /// \brief The constraint expression introduced by this declaration (by means
-  /// of a 'constrained-parameter'.
-  Expr *ConstraintExpression = nullptr;
+  /// of a 'constrained-parameter'. or a pointer to another argument from which
+  /// we inherit the constraint expression (in case of redeclaration or
+  /// instantiation)
+  llvm::PointerUnion<TemplateTypeParmDecl *, Expr *> ConstraintExpression;
 
   TemplateTypeParmDecl(DeclContext *DC, SourceLocation KeyLoc,
                        SourceLocation IdLoc, IdentifierInfo *Id,
                        bool Typename)
       : TypeDecl(TemplateTypeParm, DC, IdLoc, Id, KeyLoc), Typename(Typename) {}
 
 public:
   static TemplateTypeParmDecl *Create(const ASTContext &C, DeclContext *DC,
                                       SourceLocation KeyLoc,
                                       SourceLocation NameLoc,
public:
   unsigned getIndex() const;
 
   /// Returns whether this is a parameter pack.
   bool isParameterPack() const;
 
   /// \brief Returns the constraint expression associated with this template
   /// parameter (if any).
   Expr *getConstraintExpression() const {
-    return ConstraintExpression;
+    if (ConstraintExpression.isNull())
+      return nullptr;
+    if (auto *Inherited =
+          ConstraintExpression.dyn_cast<TemplateTypeParmDecl *>())
+      return Inherited->getConstraintExpression();
+    return ConstraintExpression.get<Expr *>();
   }
 
   /// \brief Sets the constraint expression associated with this template
   /// parameter (if any).
   void setConstraintExpression(Expr *E) {
     ConstraintExpression = E;
   }
 
+  /// \brief Sets the constraint expression associated with this template
+  /// parameter (if any).
+  void setInheritedConstraintExpression(TemplateTypeParmDecl *Prev) {
+    ConstraintExpression = Prev;
+  }
+
+  TemplateTypeParmDecl *getInheritedFromConstraintExpressionDecl() const {
+    return ConstraintExpression.get<TemplateTypeParmDecl *>();
+  }
+
+  bool constraintExpressionWasInherited() const {
+    return ConstraintExpression.is<TemplateTypeParmDecl *>();
+  }
+
   /// \brief Get the associated-constraints of this template parameter.
   /// Currently, this will either be a vector of size 1 containing the
   /// constrained-parameter constraint or an empty vector.
   ///
   /// Use this instead of getConstraintExpression for concepts APIs that
   /// accept an ArrayRef of constraint expressions.
   llvm::SmallVector<const Expr *, 1> getAssociatedConstraints() const {
-    if (ConstraintExpression)
-      return{ConstraintExpression};
+    if (Expr *CE = getConstraintExpression())
+      return{CE};
     return{};
   }
 
   SourceRange getSourceRange() const override LLVM_READONLY;
 
   // Implement isa/cast/dyncast/etc.
   static bool classof(const Decl *D) { return classofKind(D->getKind()); }
   static bool classofKind(Kind K) { return K == TemplateTypeParm; }
class NonTypeTemplateParmDecl final
   /// parameter pack, meaning that its type is a pack expansion and we
   /// already know the set of types that expansion expands to.
   bool ExpandedParameterPack = false;
 
   /// The number of types in an expanded parameter pack.
   unsigned NumExpandedTypes = 0;
 
   /// \brief The constraint expression introduced by this declaration (by means
-  /// of a 'constrained-parameter'.
-  Expr *ConstraintExpression = nullptr;
+  /// of a 'constrained-parameter'. or a pointer to another argument from which
+  /// we inherit the constraint expression (in case of redeclaration or
+  /// instantiation)
+  llvm::PointerUnion<NonTypeTemplateParmDecl *, Expr *> ConstraintExpression;
 
   size_t numTrailingObjects(
       OverloadToken<std::pair<QualType, TypeSourceInfo *>>) const {
     return NumExpandedTypes;
   }
 
   NonTypeTemplateParmDecl(DeclContext *DC, SourceLocation StartLoc,
                           SourceLocation IdLoc, unsigned D, unsigned P,
TypeSourceInfo *getExpansionTypeSourceInfo(unsigned I) const {
     auto TypesAndInfos =
         getTrailingObjects<std::pair<QualType, TypeSourceInfo *>>();
     return TypesAndInfos[I].second;
   }
 
   /// \brief Returns the constraint expression associated with this template
   /// parameter (if any).
   Expr *getConstraintExpression() const {
-    return ConstraintExpression;
+    if (ConstraintExpression.isNull())
+      return nullptr;
+    if (auto *Inherited =
+          ConstraintExpression.dyn_cast<NonTypeTemplateParmDecl *>())
+      return Inherited->getConstraintExpression();
+    return ConstraintExpression.get<Expr *>();
   }
 
   /// \brief Sets the constraint expression associated with this template
   /// parameter (if any).
   void setConstraintExpression(Expr *E) {
     ConstraintExpression = E;
   }
 
+  /// \brief Sets the constraint expression associated with this template
+  /// parameter (if any).
+  void setInheritedConstraintExpression(NonTypeTemplateParmDecl *Prev) {
+    ConstraintExpression = Prev;
+  }
+
+  NonTypeTemplateParmDecl *getInheritedFromConstraintExpressionDecl() const {
+    return ConstraintExpression.get<NonTypeTemplateParmDecl *>();
+  }
+
+  bool constraintExpressionWasInherited() const {
+    return ConstraintExpression.is<NonTypeTemplateParmDecl *>();
+  }
+
   /// \brief Get the associated-constraints of this template parameter.
   /// Currently, this will either be a vector of size 1 containing the
   /// constrained-parameter constraint or an empty vector.
   ///
   /// Use this instead of getConstraintExpression for concepts APIs that
   /// accept an ArrayRef of constraint expressions.
   llvm::SmallVector<const Expr *, 1> getAssociatedConstraints() const {
-    if (ConstraintExpression)
-      return{ConstraintExpression};
+    if (Expr *CE = getConstraintExpression())
+      return{CE};
     return{};
   }
 
   // Implement isa/cast/dyncast/etc.
   static bool classof(const Decl *D) { return classofKind(D->getKind()); }
   static bool classofKind(Kind K) { return K == NonTypeTemplateParm; }
 };
 
class TemplateTemplateParmDecl final
   /// parameter pack, meaning that it is a pack expansion and we
   /// already know the set of template parameters that expansion expands to.
   bool ExpandedParameterPack = false;
 
   /// The number of parameters in an expanded parameter pack.
   unsigned NumExpandedParams = 0;
 
   /// \brief The constraint expression introduced by this declaration (by means
-  /// of a 'constrained-parameter'.
-  Expr *ConstraintExpression = nullptr;
+  /// of a 'constrained-parameter'. or a pointer to another argument from which
+  /// we inherit the constraint expression (in case of redeclaration or
+  /// instantiation)
+  llvm::PointerUnion<TemplateTemplateParmDecl *, Expr *> ConstraintExpression;
 
   TemplateTemplateParmDecl(DeclContext *DC, SourceLocation L,
                            unsigned D, unsigned P, bool ParameterPack,
                            IdentifierInfo *Id, TemplateParameterList *Params)
       : TemplateDecl(TemplateTemplateParm, DC, L, Id, Params),
         TemplateParmPosition(D, P), ParameterPack(ParameterPack) {}
 
   TemplateTemplateParmDecl(DeclContext *DC, SourceLocation L,
public:
   }
 
   /// Removes the default argument of this template parameter.
   void removeDefaultArgument() { DefaultArgument.clear(); }
 
   /// \brief Returns the constraint expression associated with this template
   /// parameter (if any).
   Expr *getConstraintExpression() const {
-    return ConstraintExpression;
+    if (ConstraintExpression.isNull())
+      return nullptr;
+    if (auto *Inherited =
+          ConstraintExpression.dyn_cast<TemplateTemplateParmDecl *>())
+      return Inherited->getConstraintExpression();
+    return ConstraintExpression.get<Expr *>();
   }
 
   /// \brief Sets the constraint expression associated with this template
   /// parameter (if any).
   void setConstraintExpression(Expr *E) {
     ConstraintExpression = E;
   }
 
+  /// \brief Sets the constraint expression associated with this template
+  /// parameter (if any).
+  void setInheritedConstraintExpression(TemplateTemplateParmDecl *Prev) {
+    ConstraintExpression = Prev;
+  }
+
+  TemplateTemplateParmDecl *getInheritedFromConstraintExpressionDecl() const {
+    return ConstraintExpression.get<TemplateTemplateParmDecl *>();
+  }
+
+  bool constraintExpressionWasInherited() const {
+    return ConstraintExpression.is<TemplateTemplateParmDecl *>();
+  }
+
   /// \brief Get the associated-constraints of this template parameter.
   /// Currently, this will either be a vector of size 1 containing the
   /// constrained-parameter constraint or an empty vector.
   ///
   /// Use this instead of getConstraintExpression for concepts APIs that
   /// accept an ArrayRef of constraint expressions.
   llvm::SmallVector<const Expr *, 1> getAssociatedConstraints() const {
-    if (ConstraintExpression)
-      return{ConstraintExpression};
+    if (Expr *CE = getConstraintExpression())
+      return{CE};
     return{};
   }
 
   SourceRange getSourceRange() const override LLVM_READONLY {
     SourceLocation End = getLocation();
     if (hasDefaultArgument() && !defaultArgumentWasInherited())
       End = getDefaultArgument().getSourceRange().getEnd();
     return SourceRange(getTemplateParameters()->getTemplateLoc(), End);
public:
   /// struct X {
   ///   template<typename U> struct Inner;
   ///   template<typename U> struct Inner<U*>;
   /// };
   ///
   /// template<> template<typename T>
   /// struct X<int>::Inner<T*> { /* ... */ };
   /// \endcode
-  bool isMemberSpecialization() {
+  bool isMemberSpecialization() const {
     const auto *First =
-        cast<ClassTemplatePartialSpecializationDecl>(getFirstDecl());
+        cast<const ClassTemplatePartialSpecializationDecl>(getFirstDecl());
     return First->InstantiatedFromMember.getInt();
   }
 
   /// Note that this member template is a specialization.
   void setMemberSpecialization() {
     auto *First = cast<ClassTemplatePartialSpecializationDecl>(getFirstDecl());
     assert(First->InstantiatedFromMember.getPointer() &&
            "Only member templates can be member template specializations");
public:
   /// struct X {
   ///   template<typename U> U Inner;
   ///   template<typename U> U* Inner<U*> = (U*)(0);
   /// };
   ///
   /// template<> template<typename T>
   /// U* X<int>::Inner<T*> = (T*)(0) + 1;
   /// \endcode
-  bool isMemberSpecialization() {
+  bool isMemberSpecialization() const {
     const auto *First =
-        cast<VarTemplatePartialSpecializationDecl>(getFirstDecl());
+        cast<const VarTemplatePartialSpecializationDecl>(getFirstDecl());
     return First->InstantiatedFromMember.getInt();
   }
 
   /// Note that this member template is a specialization.
   void setMemberSpecialization() {
     auto *First = cast<VarTemplatePartialSpecializationDecl>(getFirstDecl());
     assert(First->InstantiatedFromMember.getPointer() &&
            "Only member templates can be member template specializations");

include/clang/AST/RecursiveASTVisitor.h

if (auto *TypeReq = dyn_cast<TypeRequirement>(Req)) {
         TRY_TO(TraverseTypeLoc(RetReq.getTrailingReturnTypeExpectedType()
                                    ->getTypeLoc()));
       else if (RetReq.isConstrainedParameter()) {
         TRY_TO(TraverseTemplateParameterListHelper(
                    RetReq.getConstrainedParamTemplateParameterList()));
         TRY_TO(TraverseTypeLoc(RetReq.getConstrainedParamExpectedType()
                                    ->getTypeLoc()));
       }
-    } else {
-      auto *NestedReq = cast<NestedRequirement>(Req);
-      if (!NestedReq->isSubstitutionFailure())
-        TRY_TO(TraverseStmt(NestedReq->getConstraintExpr()));
-    }
+    } else
+      TRY_TO(TraverseStmt(cast<NestedRequirement>(Req)->getConstraintExpr()));
 })
 
 // These literals (all of them) do not need any action.
 DEF_TRAVERSE_STMT(IntegerLiteral, {})
 DEF_TRAVERSE_STMT(FixedPointLiteral, {})
 DEF_TRAVERSE_STMT(CharacterLiteral, {})
 DEF_TRAVERSE_STMT(FloatingLiteral, {})
 DEF_TRAVERSE_STMT(ImaginaryLiteral, {})

include/clang/Basic/DiagnosticSemaKinds.td

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">;
 def note_could_not_normalize_argument_substitution_failed : Note<
-  "when substituting into %0 %1. Make sure concept arguments are "
-  "valid for any substitution">;
+  "when substituting into %0. Make sure concept arguments are valid for any "
+  "substitution">;
 def err_constrained_virtual_method : Error<
   "virtual function cannot have a requires clause">;
 def err_reference_to_function_with_unsatisfied_constraints : Error<
   "invalid reference to function %0: constraints not satisfied">;
 def note_requires_expr_ill_formed_expr : Note<
   "expression is invalid: %0">;
 def note_requires_expr_no_implicit_conversion : Note<
   "no implicit conversion exists between expression type %0 and expected type "

include/clang/Sema/Sema.h

private:
   /// were checked for subsumption and whether or not the first's constraints
   /// did in fact subsume the second's.
   llvm::DenseMap<std::pair<NamedDecl *, NamedDecl *>, bool> SubsumptionCache;
 
 public:
   /// \brief Returns whether the given declaration's associated constraints are
   /// more constrained than another declaration's according to the partial
   /// ordering of constraints.
-  /// \param NoCache If true, the subsumption cache will not be used or updated
-  /// with the result of the check. Use when the given decls may have different
-  /// associated constraints later (e.g. when D1 is a template template
-  /// parameter and AC1 are the associated constraints for the current
-  /// instantiation).
   bool
   IsAtLeastAsConstrained(NamedDecl *D1, ArrayRef<const Expr *> AC1,
-                         NamedDecl *D2, ArrayRef<const Expr *> AC2,
-                         bool NoCache = false);
+                         NamedDecl *D2, ArrayRef<const Expr *> AC2);
+
+  /// \brief Returns whether the given declaration's associated constraints are
+  /// more constrained than another declaration's according to the partial
+  /// ordering of constraints.
+  bool IsAtLeastAsConstrained(ArrayRef<const Expr *> AC1,
+                              const MultiLevelTemplateArgumentList &MLTAL1,
+                              ArrayRef<const Expr *> AC2,
+                              const MultiLevelTemplateArgumentList &MLTAL2);
 
   /// \brief 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);
+  bool MaybeEmitAmbiguousAtomicConstraintsDiagnostic(NamedDecl *D1,
+      ArrayRef<const Expr *> AC1, const MultiLevelTemplateArgumentList &MLTAL1,
+      NamedDecl *D2, ArrayRef<const Expr *> AC2,
+      const MultiLevelTemplateArgumentList &MLTAL2);
 
   /// \brief Check whether the given list of constraint expressions are
   /// satisfied (as if in a 'conjunction') given template arguments.
   /// \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.
   /// \param TemplateIDRange The source range of the template id that
   /// caused the constraints check.
   /// \param Satisfaction if true is returned, will contain details of the
   /// satisfaction, with enough information to diagnose an unsatisfied
   /// expression.
   /// \returns true if an error occurred and satisfaction could not be checked,
   /// false otherwise.
-  bool CheckConstraintSatisfaction(TemplateDecl *Template,
-                                   ArrayRef<const Expr *> ConstraintExprs,
-                                   ArrayRef<TemplateArgument> TemplateArgs,
-                                   SourceRange TemplateIDRange,
-                                   ConstraintSatisfaction &Satisfaction);
-
-  bool CheckConstraintSatisfaction(ClassTemplatePartialSpecializationDecl *TD,
-                                   ArrayRef<const Expr *> ConstraintExprs,
-                                   ArrayRef<TemplateArgument> TemplateArgs,
-                                   SourceRange TemplateIDRange,
-                                   ConstraintSatisfaction &Satisfaction);
+  bool CheckConstraintSatisfaction(NamedDecl *Template,
+      const MultiLevelTemplateArgumentList &TemplateArgs,
+      SourceRange TemplateIDRange, ConstraintSatisfaction &Satisfaction);
 
-  bool CheckConstraintSatisfaction(VarTemplatePartialSpecializationDecl *TD,
-                                   ArrayRef<const Expr *> ConstraintExprs,
-                                   ArrayRef<TemplateArgument> TemplateArgs,
-                                   SourceRange TemplateIDRange,
-                                   ConstraintSatisfaction &Satisfaction);
+  bool CheckConstraintSatisfaction(NestedRequirement *Req,
+      const Expr *ConstraintExpr,
+      const MultiLevelTemplateArgumentList &TemplateArgs,
+      ConstraintSatisfaction &Satisfaction, bool &IsDependent,
+      bool &ContainsUnexpandedParameterPack);
 
   /// \brief Check whether the given non-dependent constraint expression is
   /// satisfied. Returns false and updates Satisfaction with the satisfaction
   /// verdict if successful, emits a diagnostic and returns true if an error
   /// occured and satisfaction could not be determined.
   ///
   /// \returns true if an error occurred, false otherwise.
   bool CheckConstraintSatisfaction(const Expr *ConstraintExpr,
bool CheckTemplateTypeArgument(TemplateTypeParmDecl *Param,
                            SmallVectorImpl<TemplateArgument> &Converted);
 
   bool CheckTemplateArgument(TemplateTypeParmDecl *Param,
                              TypeSourceInfo *Arg);
   ExprResult CheckTemplateArgument(NonTypeTemplateParmDecl *Param,
                                    QualType InstantiatedParamType, Expr *Arg,
                                    TemplateArgument &Converted,
                                CheckTemplateArgumentKind CTAK = CTAK_Specified);
-  bool CheckTemplateTemplateArgument(TemplateTemplateParmDecl *Param,
-                                     TemplateParameterList *Params,
-                                     TemplateArgumentLoc &Arg);
+  bool CheckTemplateArgument(TemplateTemplateParmDecl *Param,
+                             TemplateArgumentLoc &Arg,
+                             unsigned ArgumentPackIndex,
+                             ArrayRef<TemplateArgument> Converted);
 
   ExprResult
   BuildExpressionFromDeclTemplateArgument(const TemplateArgument &Arg,
                                           QualType ParamType,
                                           SourceLocation Loc);
   ExprResult
   BuildExpressionFromIntegralTemplateArgument(const TemplateArgument &Arg,
                                               SourceLocation Loc);
static void MarkDeducedTemplateParameters(ASTContext &Ctx,
                                   const FunctionTemplateDecl *FunctionTemplate,
                                   llvm::SmallBitVector &Deduced);
 
   //===--------------------------------------------------------------------===//
   // C++ Template Instantiation
   //
 
   MultiLevelTemplateArgumentList
-  getTemplateInstantiationArgs(NamedDecl *D,
+  getTemplateInstantiationArgs(Decl *D,
                                const TemplateArgumentList *Innermost = nullptr,
                                bool RelativeToPrimary = false,
                                const FunctionDecl *Pattern = nullptr);
 
   /// A context in which code is being synthesized (where a source location
   /// alone is not sufficient to identify the context). This covers template
   /// instantiation and various forms of implicitly-generated functions.
   struct CodeSynthesisContext {
struct InstantiatingTemplate {
     /// Determines whether we have exceeded the maximum
     /// recursive template instantiations.
     bool isInvalid() const { return Invalid; }
 
     /// Determine whether we are already instantiating this
     /// specialization in some surrounding active instantiation.
     bool isAlreadyInstantiating() const { return AlreadyInstantiating; }
 
+    InstantiatingTemplate(InstantiatingTemplate&&);
+
   private:
     Sema &SemaRef;
     bool Invalid;
     bool AlreadyInstantiating;
     bool CheckInstantiationDepth(SourceLocation PointOfInstantiation,
                                  SourceRange InstantiationRange);
 
     InstantiatingTemplate(
SubstTemplateName(NestedNameSpecifierLoc QualifierLoc, TemplateName Name,
                     SourceLocation Loc,
                     const MultiLevelTemplateArgumentList &TemplateArgs);
   bool Subst(const TemplateArgumentLoc *Args, unsigned NumArgs,
              TemplateArgumentListInfo &Result,
              const MultiLevelTemplateArgumentList &TemplateArgs);
 
   void InstantiateExceptionSpec(SourceLocation PointOfInstantiation,
                                 FunctionDecl *Function);
-  bool CheckInstantiatedFunctionTemplateConstraints(
-      SourceLocation PointOfInstantiation, FunctionDecl *Decl,
-      ArrayRef<TemplateArgument> TemplateArgs,
+  bool CheckFunctionConstraints(FunctionDecl *Decl,
       ConstraintSatisfaction &Satisfaction);
   FunctionDecl *InstantiateFunctionDeclaration(FunctionTemplateDecl *FTD,
                                                const TemplateArgumentList *Args,
                                                SourceLocation Loc);
   void InstantiateFunctionDefinition(SourceLocation PointOfInstantiation,
                                      FunctionDecl *Function,
                                      bool Recursive = false,
                                      bool DefinitionRequired = false,

include/clang/Sema/SemaConcept.h

 #include "clang/AST/Expr.h"
 #include "clang/Basic/SourceLocation.h"
 #include "llvm/ADT/PointerUnion.h"
 #include "llvm/ADT/SmallVector.h"
 #include <string>
 #include <utility>
 namespace clang {
 class ConceptSpecializationExpr;
+class MultiLevelTemplateArgumentList;
 class Sema;
 
 /// \brief The result of a constraint satisfaction check, containing the
 /// necessary information to diagnose an unsatisfied constraint.
 struct ConstraintSatisfaction {
   using SubstitutionDiagnostic = std::pair<SourceLocation, std::string>;
   using Detail = llvm::PointerUnion<Expr *, SubstitutionDiagnostic *>;
 
public:
   static bool classof(const Requirement *R) {
     return R->getKind() == RK_Compound || R->getKind() == RK_Simple;
   }
 };
 
 /// \brief A requires-expression requirement which is satisfied when a general
 /// constraint expression is satisfied ('nested' requirements).
 class NestedRequirement : public Requirement {
-  llvm::PointerUnion<Expr *, SubstitutionDiagnostic *> Value;
+  Expr *ConstraintExpr;
   ConstraintSatisfaction Satisfaction;
 
 public:
   friend class ASTStmtReader;
   friend class ASTStmtWriter;
 
-  NestedRequirement(SubstitutionDiagnostic *SubstDiag) :
-      Requirement(RK_Nested, /*Dependent=*/false,
-                  /*ContainsUnexpandedParameterPack*/false,
-                  /*Satisfied=*/false), Value(SubstDiag) {}
-
   NestedRequirement(Expr *Constraint) :
-      Requirement(RK_Nested, /*Dependent=*/true,
+      Requirement(RK_Nested, /*IsDependent=*/true,
                   Constraint->containsUnexpandedParameterPack()),
-      Value(Constraint) {
-    assert(Constraint->isInstantiationDependent() &&
-           "Nested requirement with Non-dependent constraint must be "
-           "constructed with a Sema& or a ConstraintSatisfaction object");
+      ConstraintExpr(Constraint) {
+    assert(Constraint->isInstantiationDependent() && "Non-dependent constraint "
+           "expressions must be provided along a Sema& or a precalculated "
+           "ConstraintSatisfaction");
   }
-  NestedRequirement(Sema &S, Expr *Constraint);
+  NestedRequirement(Sema &S, Expr *Constraint,
+                    const MultiLevelTemplateArgumentList &TemplateArgs);
   NestedRequirement(Expr *Constraint, ConstraintSatisfaction Satisfaction) :
       Requirement(RK_Nested, false, false, Satisfaction.IsSatisfied),
-      Value(Constraint), Satisfaction(std::move(Satisfaction)) {}
-
-  bool isSubstitutionFailure() const {
-    return Value.is<SubstitutionDiagnostic *>();
-  }
-  SubstitutionDiagnostic *getSubstitutionDiagnostic() const {
-    assert(isSubstitutionFailure() &&
-           "getSubstitutionDiagnostic() may not be called when there was no "
-           "substitution failure.");
-    return Value.get<SubstitutionDiagnostic *>();
-  }
+      ConstraintExpr(Constraint), Satisfaction(std::move(Satisfaction)) {}
 
   Expr *getConstraintExpr() const {
-    assert(!isSubstitutionFailure() && "getConstraintExpr() may not be called "
-                                       "on nested requirements with "
-                                       "substitution failures.");
-    return Value.get<Expr *>();
+    return ConstraintExpr;
   }
 
   void Diagnose(Sema &S, bool First) const override;
 
   static bool classof(const Requirement *R) {
     return R->getKind() == RK_Nested;
   }
 };
 
 } // clang
 
 #endif
 No newline at end of file

lib/AST/DeclTemplate.cpp

 //===----------------------------------------------------------------------===//
 
 
 TemplateParameterList::TemplateParameterList(const ASTContext& C,
                                              SourceLocation TemplateLoc,
                                              SourceLocation LAngleLoc,
                                              ArrayRef<NamedDecl *> Params,
                                              SourceLocation RAngleLoc,
-                                             Expr *RequiresClause)
+                                             Expr *RequiresClause,
+                                    TemplateParameterList *InheritedConstraints)
     : TemplateLoc(TemplateLoc), LAngleLoc(LAngleLoc), RAngleLoc(RAngleLoc),
       NumParams(Params.size()), ContainsUnexpandedParameterPack(false),
-      HasRequiresClause(RequiresClause != nullptr),
+      HasRequiresClause(RequiresClause != nullptr ||
+          (InheritedConstraints && InheritedConstraints->HasRequiresClause)),
       HasConstrainedParameters(false) {
   for (unsigned Idx = 0; Idx < NumParams; ++Idx) {
     NamedDecl *P = Params[Idx];
     begin()[Idx] = P;
 
     bool IsPack = P->isTemplateParameterPack();
     if (const auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(P)) {
       if (!IsPack && NTTP->getType()->containsUnexpandedParameterPack())
if (const auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(P)) {
         ContainsUnexpandedParameterPack = true;
       HasConstrainedParameters = true;
     }
     // FIXME: If a default argument contains an unexpanded parameter pack, the
     // template parameter list does too.
   }
 
   if (HasRequiresClause) {
+    auto &P = *getTrailingObjects<llvm::PointerUnion<Expr *,
+                                                    TemplateParameterList *>>();
+    if (InheritedConstraints)
+      P = InheritedConstraints;
+    else {
       if (RequiresClause->containsUnexpandedParameterPack())
         ContainsUnexpandedParameterPack = true;
-    *getTrailingObjects<Expr *>() = RequiresClause;
+      P = RequiresClause;
+    }
   }
 }
 
 TemplateParameterList *
 TemplateParameterList::Create(const ASTContext &C, SourceLocation TemplateLoc,
                               SourceLocation LAngleLoc,
                               ArrayRef<NamedDecl *> Params,
-                              SourceLocation RAngleLoc, Expr *RequiresClause) {
-  void *Mem = C.Allocate(totalSizeToAlloc<NamedDecl *, Expr *>(
-                             Params.size(), RequiresClause ? 1u : 0u),
+                              SourceLocation RAngleLoc, Expr *RequiresClause,
+                              TemplateParameterList *InheritedConstraints) {
+  assert(!RequiresClause || !InheritedConstraints);
+  void *Mem = C.Allocate(totalSizeToAlloc<NamedDecl *,
+                                          llvm::PointerUnion<Expr *,
+                                                      TemplateParameterList *>>(
+                             Params.size(), RequiresClause ||
+                           (InheritedConstraints &&
+                            InheritedConstraints->HasRequiresClause) ? 1u : 0u),
                          alignof(TemplateParameterList));
   return new (Mem) TemplateParameterList(C, TemplateLoc, LAngleLoc, Params,
-                                         RAngleLoc, RequiresClause);
+                                         RAngleLoc, RequiresClause,
+                                         InheritedConstraints);
 }
 
 unsigned TemplateParameterList::getMinRequiredArguments() const {
   unsigned NumRequiredArgs = 0;
   for (const NamedDecl *P : asArray()) {
     if (P->isTemplateParameterPack()) {
       if (const auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(P))
         if (NTTP->isExpandedParameterPack()) {

lib/AST/StmtPrinter.cpp

if (auto *TypeReq = dyn_cast<TypeRequirement>(Req)) {
                                     ConstraintExprBuf);
             OS << ExpectedTypeBuf;
           }
         }
       }
     } else {
       auto *NestedReq = cast<NestedRequirement>(Req);
       OS << "requires ";
-      if (NestedReq->isSubstitutionFailure())
-        OS << "<<error-expression>>";
-      else
-        PrintExpr(NestedReq->getConstraintExpr());
     }
     OS << "; ";
   }
   OS << "}";
 }
 
 // C++ Coroutines TS
 

lib/AST/StmtProfile.cpp

if (auto *TypeReq = dyn_cast<TypeRequirement>(Req)) {
         VisitType(RetReq.getConstrainedParamExpectedType()->getType());
       } else {
         assert(RetReq.isSubstitutionFailure());
         ID.AddInteger(3);
       }
     } else {
       ID.AddInteger(Requirement::RK_Nested);
       auto *NestedReq = cast<NestedRequirement>(Req);
-      ID.AddBoolean(NestedReq->isSubstitutionFailure());
-      if (!NestedReq->isSubstitutionFailure())  
-        Visit(NestedReq->getConstraintExpr());
     }
   }
 }
 
 static Stmt::StmtClass DecodeOperatorCall(const CXXOperatorCallExpr *S,
                                           UnaryOperatorKind &UnaryOp,
                                           BinaryOperatorKind &BinaryOp) {
   switch (S->getOperator()) {

lib/Sema/SemaConcept.cpp

 #include "clang/Sema/SemaDiagnostic.h"
 #include "clang/AST/RecursiveASTVisitor.h"
 #include "clang/Sema/TemplateDeduction.h"
 #include "clang/Sema/Template.h"
 #include "clang/Sema/Overload.h"
 #include "clang/Sema/Initialization.h"
 #include "clang/Sema/SemaInternal.h"
 #include "clang/AST/ExprCXX.h"
+#include "llvm/ADT/Optional.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/PointerUnion.h"
 using namespace clang;
 using namespace sema;
 
 bool Sema::CheckConstraintExpression(Expr *ConstraintExpression,
                                      Expr **Culprit) {
   // C++2a [temp.constr.atomic]p1
bool Sema::CheckRedeclarationConstraintMatch(ArrayRef<const Expr *> OldAC,
   return true;
 }
 
 void
 Sema::DiagnoseRedeclarationConstraintMismatch(SourceLocation Old,
                                               SourceLocation New){
   Diag(New, diag::err_template_different_associated_constraints);
 
-  Diag(Old, diag::note_template_prev_declaration) << /*declaration*/0;
+  Diag(Old, diag::note_template_decl_here);
 }
 
 template <typename AtomicEvaluator>
 static bool
 calculateConstraintSatisfaction(Sema &S, const Expr *ConstraintExpr,
                                 ConstraintSatisfaction &Satisfaction,
                                 AtomicEvaluator &&Evaluator) {
   if (auto *BO = dyn_cast<BinaryOperator>(ConstraintExpr)) {
calculateConstraintSatisfaction(Sema &S, const Expr *ConstraintExpr,
   Satisfaction.IsSatisfied = EvalResult.Val.getInt().getBoolValue();
   if (!Satisfaction.IsSatisfied)
     Satisfaction.Details.emplace_back(ConstraintExpr,
                                       SubstitutedAtomicExpr.get());
 
   return false;
 }
 
-template <typename TemplateDeclT>
-static bool calculateConstraintSatisfaction(
-    Sema &S, TemplateDeclT *Template, ArrayRef<TemplateArgument> TemplateArgs,
-    SourceLocation TemplateNameLoc, MultiLevelTemplateArgumentList &MLTAL,
-    const Expr *ConstraintExpr, ConstraintSatisfaction &Satisfaction) {
+template<typename SubstitutionInstantiatingTemplateCreator>
+static bool calculateConstraintSatisfaction(Sema &S,
+    SubstitutionInstantiatingTemplateCreator Creator,
+    const MultiLevelTemplateArgumentList &TemplateArgs,
+    SourceLocation TemplateNameLoc, const Expr *ConstraintExpr,
+    ConstraintSatisfaction &Satisfaction,
+    bool *ContainsUnexpandedParameterPack = nullptr,
+    bool *IsDependent = nullptr) {
   return calculateConstraintSatisfaction(
       S, ConstraintExpr, Satisfaction, [&](const Expr *AtomicExpr) {
         EnterExpressionEvaluationContext ConstantEvaluated(
             S, Sema::ExpressionEvaluationContext::ConstantEvaluated);
 
         // Atomic constraint - substitute arguments and check satisfaction.
         ExprResult SubstitutedExpression;
         {
           TemplateDeductionInfo Info(TemplateNameLoc);
-          Sema::InstantiatingTemplate Inst(S, AtomicExpr->getBeginLoc(),
-              Sema::InstantiatingTemplate::ConstraintSubstitution{}, Template,
-              Info, AtomicExpr->getSourceRange());
+          Sema::InstantiatingTemplate Inst(
+              Creator(AtomicExpr->getBeginLoc(), AtomicExpr->getSourceRange(),
+                      Info));
           if (Inst.isInvalid())
             return ExprError();
           // We do not want error diagnostics escaping here.
           Sema::SFINAETrap Trap(S);
           SubstitutedExpression = S.SubstExpr(const_cast<Expr *>(AtomicExpr),
-                                              MLTAL);
+                                              TemplateArgs);
           if (SubstitutedExpression.isInvalid()) {
             // 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();
return calculateConstraintSatisfaction(
                 new (S.Context) ConstraintSatisfaction::SubstitutionDiagnostic{
                         SubstDiag.first,
                         std::string(DiagString.begin(), DiagString.end())});
             Satisfaction.IsSatisfied = false;
             return ExprEmpty();
           }
         }
 
+        if (ContainsUnexpandedParameterPack != nullptr)
+          *ContainsUnexpandedParameterPack |=
+              SubstitutedExpression.get()->containsUnexpandedParameterPack();
+
+        if (SubstitutedExpression.get()->isInstantiationDependent()) {
+          // This might happen when constraint expressions present somewhere in
+          // a member declaration of a template are instantiated:
+          //
+          // template<typename T>
+          // struct S {
+          //   template<typename U,
+          //            decltype(
+          //              requires { requires sizeof(T{} + U{}) > 1); }
+          //            ) W>
+          //   struct M { };
+          // }
+          //
+          // Referencing S<int> will trigger the instantiation of the
+          // nested-requirement, with only the <T> argument, and no the <U>
+          // argument. We will treat this as satisfied for now because the
+          // expression will be instantiated again anyway with both the <T> and
+          // the <U> arguments.
+          if (IsDependent != nullptr)
+            *IsDependent = true;
+          Satisfaction.IsSatisfied = true;
+          return ExprEmpty();
+        }
+
         if (!S.CheckConstraintExpression(SubstitutedExpression.get()))
           return ExprError();
 
         return SubstitutedExpression;
       });
 }
 
-template<typename TemplateDeclT>
-static bool CheckConstraintSatisfaction(Sema &S, TemplateDeclT *Template,
-                                        ArrayRef<const Expr *> ConstraintExprs,
-                                        ArrayRef<TemplateArgument> TemplateArgs,
-                                        SourceRange TemplateIDRange,
-                                        ConstraintSatisfaction &Satisfaction) {
-  if (ConstraintExprs.empty()) {
-    Satisfaction.IsSatisfied = true;
-    return false;
-  }
-
-  for (auto& Arg : TemplateArgs)
-    if (Arg.isInstantiationDependent()) {
-      // No need to check satisfaction for dependent constraint expressions.
-      Satisfaction.IsSatisfied = true;
-      return false;
-    }
-
-  Sema::InstantiatingTemplate Inst(S, TemplateIDRange.getBegin(),
-      Sema::InstantiatingTemplate::ConstraintsCheck{}, Template, TemplateArgs,
-      TemplateIDRange);
-  if (Inst.isInvalid())
-    return true;
-
-  MultiLevelTemplateArgumentList MLTAL;
-  MLTAL.addOuterTemplateArguments(TemplateArgs);
-
+template<typename SubstitutionInstantiatingTemplateCreator>
+static bool
+CheckConstraintSatisfaction(Sema &S, ArrayRef<const Expr *> ConstraintExprs,
+                            const MultiLevelTemplateArgumentList &TemplateArgs,
+                            SubstitutionInstantiatingTemplateCreator Creator,
+                            ConstraintSatisfaction &Satisfaction,
+                            bool *ContainsUnexpandedParameterPack = nullptr,
+                            bool *IsDependent = nullptr) {
   for (const Expr *ConstraintExpr : ConstraintExprs) {
-    if (calculateConstraintSatisfaction(S, Template, TemplateArgs,
-                                        TemplateIDRange.getBegin(), MLTAL,
-                                        ConstraintExpr, Satisfaction))
+    if (calculateConstraintSatisfaction(S, Creator, TemplateArgs,
+                                        TemplateIDRange.getBegin(),
+                                        ConstraintExpr, Satisfaction,
+                                        ContainsUnexpandedParameterPack,
+                                        IsDependent))
       return true;
     if (!Satisfaction.IsSatisfied)
       // [temp.constr.op] p2
       //   [...] To determine if a conjunction is satisfied, the satisfaction
       //   of the first operand is checked. If that is not satisfied, the
       //   conjunction is not satisfied. [...]
       return false;
   }
   return false;
 }
 
-bool Sema::CheckConstraintSatisfaction(TemplateDecl *Template,
-                                       ArrayRef<const Expr *> ConstraintExprs,
-                                       ArrayRef<TemplateArgument> TemplateArgs,
-                                       SourceRange TemplateIDRange,
-                                       ConstraintSatisfaction &Satisfaction) {
-  return ::CheckConstraintSatisfaction(*this, Template, ConstraintExprs,
-                                       TemplateArgs, TemplateIDRange,
-                                       Satisfaction);
+bool Sema::CheckConstraintSatisfaction(NamedDecl *Template,
+    const MultiLevelTemplateArgumentList &TemplateArgs,
+    SourceRange TemplateIDRange, ConstraintSatisfaction &Satisfaction) {
+  if (ConstraintExprs.empty()) {
+    Satisfaction.IsSatisfied = true;
+    return false;
   }
+  InstantiatingTemplate Inst(*this, TemplateIDRange.getBegin(),
+      InstantiatingTemplate::ConstraintsCheck{}, Template,
+      TemplateArgs.getInnermost(), TemplateIDRange);
+  if (Inst.isInvalid())
+    return true;
 
-bool
-Sema::CheckConstraintSatisfaction(ClassTemplatePartialSpecializationDecl* Part,
-                                  ArrayRef<const Expr *> ConstraintExprs,
-                                  ArrayRef<TemplateArgument> TemplateArgs,
-                                  SourceRange TemplateIDRange,
-                                  ConstraintSatisfaction &Satisfaction) {
-  return ::CheckConstraintSatisfaction(*this, Part, ConstraintExprs,
-                                       TemplateArgs, TemplateIDRange,
-                                       Satisfaction);
+  return ::CheckConstraintSatisfaction(*this, ConstraintExprs,
+      [&] (SourceLocation PointOfInstantiation,
+           SourceRange InstantiationRange,
+           TemplateDeductionInfo &DeductionInfo) {
+          return std::move(InstantiatingTemplate(*this, PointOfInstantiation,
+              InstantiatingTemplate::ConstraintSubstitution{}, Template,
+              DeductionInfo, InstantiationRange));
+      }, Satisfaction);
 }
 
-bool
-Sema::CheckConstraintSatisfaction(VarTemplatePartialSpecializationDecl* Partial,
-                                  ArrayRef<const Expr *> ConstraintExprs,
-                                  ArrayRef<TemplateArgument> TemplateArgs,
-                                  SourceRange TemplateIDRange,
-                                  ConstraintSatisfaction &Satisfaction) {
-  return ::CheckConstraintSatisfaction(*this, Partial, ConstraintExprs,
-                                       TemplateArgs, TemplateIDRange,
-                                       Satisfaction);
+bool Sema::CheckConstraintSatisfaction(NestedRequirement *Req,
+    const Expr *ConstraintExpr,
+    const MultiLevelTemplateArgumentList &TemplateArgs,
+    ConstraintSatisfaction &Satisfaction,
+    bool &IsDependent, bool &ContainsUnexpandedParameterPack) {
+  IsDependent = false;
+  ContainsUnexpandedParameterPack = false;
+
+  InstantiatingTemplate Inst(*this, ConstraintExpr->getBeginLoc(), Req,
+      InstantiatingTemplate::ConstraintsCheck{},
+      ConstraintExpr->getSourceRange());
+  if (Inst.isInvalid())
+    return true;
+
+  return ::CheckConstraintSatisfaction(*this, {ConstraintExpr},
+      TemplateArgs, ConstraintExpr->getSourceRange(),
+      [&] (SourceLocation PointOfInstantiation,
+           SourceRange InstantiationRange,
+           TemplateDeductionInfo &DeductionInfo) {
+          return std::move(InstantiatingTemplate(*this, PointOfInstantiation,
+              Req, DeductionInfo, InstantiationRange));
+      }, Satisfaction, &ContainsUnexpandedParameterPack, &IsDependent);
 }
 
 bool Sema::CheckConstraintSatisfaction(const Expr *ConstraintExpr,
                                        ConstraintSatisfaction &Satisfaction) {
   return calculateConstraintSatisfaction(
       *this, ConstraintExpr, Satisfaction,
       [](const Expr *AtomicExpr) -> ExprResult {
         return ExprResult(const_cast<Expr *>(AtomicExpr));
       });
 }
 
 bool Sema::EnsureTemplateArgumentListConstraints(
     TemplateDecl *TD, ArrayRef<TemplateArgument> TemplateArgs,
     SourceRange TemplateIDRange) {
   ConstraintSatisfaction Satisfaction;
+  TemplateArgumentList TAL(TemplateArgumentList::OnStack, TemplateArgs);
+  MultiLevelTemplateArgumentList MLTAL =
+      getTemplateInstantiationArgs(TD, /*Innermost=*/&TAL);
   if (CheckConstraintSatisfaction(TD, TD->getAssociatedConstraints(),
-                                  TemplateArgs, TemplateIDRange, Satisfaction))
+                                  MLTAL, TemplateIDRange, Satisfaction))
     return true;
 
   if (!Satisfaction.IsSatisfied) {
     SmallString<128> TemplateArgString;
     TemplateArgString = " ";
     TemplateArgString += getTemplateArgumentBindingsText(
         TD->getTemplateParameters(), TemplateArgs.data(), TemplateArgs.size());
 
assert(!Satisfaction.IsSatisfied &&
          "Attempted to diagnose a satisfied constraint");
   for (auto &Pair : Satisfaction.Details) {
     diagnoseUnsatisfiedConstraintExpr(*this, Pair.first, Pair.second, First);
     First = false;
   }
 }
 namespace {
 struct AtomicConstraint {
+  const Expr *ConstraintExpr;
+  llvm::SmallVector<TemplateArgument, 3> ParameterMapping;
+
   AtomicConstraint(const Expr *ConstraintExpr,
-      const ASTTemplateArgumentListInfo *ParameterMapping = nullptr) :
-      ConstraintExpr{ConstraintExpr}, ParameterMapping{ParameterMapping} {}
+      ArrayRef<TemplateArgument> ParameterMapping) :
+      ConstraintExpr{ConstraintExpr} {
+    this->ParameterMapping.assign(ParameterMapping.data(),
+                                  ParameterMapping.data() +
+                                  ParameterMapping.size());
+  }
 
   bool hasMatchingParameterMapping(ASTContext &C,
                                    const AtomicConstraint &Other) const {
-    if ((!ParameterMapping) != (!Other.ParameterMapping))
-      return false;
-    if (!ParameterMapping)
-      return true;
-    if (ParameterMapping->NumTemplateArgs !=
-        Other.ParameterMapping->NumTemplateArgs)
+    if (ParameterMapping.size() != Other.ParameterMapping.size())
       return false;
 
-    for (unsigned I = 0, S = ParameterMapping->NumTemplateArgs; I < S; ++I)
-      if (!C.getCanonicalTemplateArgument(
-                ParameterMapping->arguments()[I].getArgument())
+    for (unsigned I = 0, S = ParameterMapping.size(); I < S; ++I)
+      if (!C.getCanonicalTemplateArgument(ParameterMapping[I])
                .structurallyEquals(C.getCanonicalTemplateArgument(
-                   Other.ParameterMapping->arguments()[I].getArgument())))
+                   Other.ParameterMapping[I])))
         return false;
     return true;
   }
 
   bool subsumes(ASTContext &C, const AtomicConstraint &Other) const {
     // C++ [temp.constr.order] p2
     //   - an atomic constraint A subsumes another atomic constraint B
     //     if and only if the A and B are identical [...]
     //
     // C++ [temp.constr.atomic] p2
     //   Two atomic constraints are identical if they are formed from the
     //   same expression and the targets of the parameter mappings are
     //   equivalent according to the rules for expressions [...]
 
     // We do not actually substitute the parameter mappings, therefore the
     // constraint expressions are the originals, and comparing them will
     // suffice.
     if (ConstraintExpr != Other.ConstraintExpr)
       return false;
 
     // Check that the parameter lists are identical
     return hasMatchingParameterMapping(C, Other);
   }
-
-  const Expr *ConstraintExpr;
-  const ASTTemplateArgumentListInfo *ParameterMapping;
 };
 
 /// \brief A normalized constraint, as defined in C++ [temp.constr.normal], is
 /// either an atomic constraint, a conjunction of normalized constraints or a
 /// disjunction of normalized constraints.
 struct NormalizedConstraint {
   enum CompoundConstraintKind { CCK_Conjunction, CCK_Disjunction };
 
NormalizedConstraint &getRHS() const {
     return Constraint.get<CompoundConstraint>().getPointer()->second;
   }
 
   AtomicConstraint *getAtomicConstraint() const {
     assert(isAtomic() &&
            "getAtomicConstraint called on non-atomic constraint.");
     return Constraint.get<AtomicConstraint *>();
   }
-  static llvm::Optional<NormalizedConstraint> fromConstraintExpr(
-      Sema &S, const Expr *E, TemplateDecl *TD = nullptr,
-      const ASTTemplateArgumentListInfo *ParameterMapping = nullptr) {
+  static llvm::Optional<NormalizedConstraint> fromConstraintExpr(Sema &S,
+      const Expr *E,
+      const MultiLevelTemplateArgumentList *ParameterMapping = nullptr) {
     assert(E != nullptr);
 
     // C++ [temp.constr.normal]p1.1
     // [...]
     // - The normal form of an expression (E) is the normal form of E.
     // [...]
     if (auto *P = dyn_cast<const ParenExpr>(E))
-      return fromConstraintExpr(S, P->getSubExpr(), TD, ParameterMapping);
+      return fromConstraintExpr(S, P->getSubExpr(), ParameterMapping);
     if (auto *BO = dyn_cast<const BinaryOperator>(E)) {
       if (BO->getOpcode() == BO_LAnd || BO->getOpcode() == BO_LOr) {
-        auto LHS = fromConstraintExpr(S, BO->getLHS(), TD, ParameterMapping);
+        auto LHS = fromConstraintExpr(S, BO->getLHS(), ParameterMapping);
         if (!LHS)
           return llvm::Optional<NormalizedConstraint>{};
-        auto RHS = fromConstraintExpr(S, BO->getRHS(), TD, ParameterMapping);
+        auto RHS = fromConstraintExpr(S, BO->getRHS(), ParameterMapping);
         if (!RHS)
           return llvm::Optional<NormalizedConstraint>{};
 
         return NormalizedConstraint(
             S.Context, std::move(*LHS), std::move(*RHS),
             BO->getOpcode() == BO_LAnd ? CCK_Conjunction : CCK_Disjunction);
       }
     } else if (auto *CSE = dyn_cast<const ConceptSpecializationExpr>(E)) {
if (auto *BO = dyn_cast<const BinaryOperator>(E)) {
           // void foo() requires C<Ts...> // The immediate constraint expr
           //                              // contains a CSE whose parameters
           //                              // are not mappable to arguments
           //                              // without concrete values.
           // {}
           //
           // Just treat C<Ts...> as an atomic constraint.
           return NormalizedConstraint{new (S.Context)
-                                          AtomicConstraint(E, Mapping)};
-
+                                          AtomicConstraint(E, TempList)};
+        MultiLevelTemplateArgumentList MLTAL;
+        MLTAL.addOuterTemplateArguments(TempList);
         return fromConstraintExpr(S,
                                   CSE->getNamedConcept()->getConstraintExpr(),
-                                  CSE->getNamedConcept(), Mapping);
+                                  &MLTAL);
       }
 
       // This is not a top level CSE.
       //
       // template<typename T1, typename T2>
       // concept C1 = true;
       //
       // template<typename T, typename U>
       // concept C2 = C1<U, T>; -> We are here.
       //                           Mapping is {T1=U, T2=T}
-      //                           ParameterMapping is {T=X, U=Y}, TD is C2
+      //                           ParameterMapping is {T=X, U=Y}
       //
       // template<typename X, typename Y>
       // void foo() requires C2<X, Y> {}
       //
       // We would like to substitute ParameterMapping into Mapping, to get
       // ParameterMapping={T1=Y, T2=X} for the next level down.
       // Instead of doing the direct substitution of ParameterMapping into
       // Mapping, we instead substitute ParameterMapping into C1<U, T> and take
       // the substituted argument list as the ParameterMapping for the next
       // level down.
-      assert(TD && "ParameterMapping provided without TemplateDecl");
-
-      TemplateArgumentListInfo TALI(ParameterMapping->LAngleLoc,
-                                    ParameterMapping->RAngleLoc);
-      for (auto &Arg : ParameterMapping->arguments())
-        TALI.addArgument(Arg);
-      llvm::SmallVector<TemplateArgument, 4> TempList;
-      bool InstantiationDependent = false;
-      bool Success =
-          !S.CheckTemplateArgumentList(TD, ParameterMapping->LAngleLoc,
-                                       TALI, /*PartialTemplateArgs=*/false,
-                                       TempList,
-                                       /*UpdateArgsWithConversions=*/false,
-                                       &InstantiationDependent) &&
-          !InstantiationDependent;
-      assert(Success && "ParameterMapping should have already been cheked "
-                        "against template argument list earlier.");
 
       auto DiagnoseSubstitutionError = [&](unsigned int Diag) {
-        std::string TemplateArgString = S.getTemplateArgumentBindingsText(
-            TD->getTemplateParameters(), TempList.data(), TempList.size());
         S.Diag(CSE->getBeginLoc(), Diag)
-            << const_cast<ConceptSpecializationExpr *>(CSE)
-            << TemplateArgString;
+            << const_cast<ConceptSpecializationExpr *>(CSE);
       };
 
-      MultiLevelTemplateArgumentList MLTAL;
-      MLTAL.addOuterTemplateArguments(TempList);
-
       ExprResult Result = S.SubstExpr(
-          const_cast<ConceptSpecializationExpr *>(CSE), MLTAL);
+          const_cast<ConceptSpecializationExpr *>(CSE), *ParameterMapping);
       if (!Result.isUsable() || Result.isInvalid()) {
         // C++ [temp.constr.normal]
         // If any such substitution results in an invalid type or
         // expression, the program is ill-formed; no diagnostic is required.
 
         // A diagnostic was already emitted from the substitution , but
         // we'll let the user know why it's not SFINAEd from them.
         DiagnoseSubstitutionError(
             diag::note_could_not_normalize_argument_substitution_failed);
         return llvm::Optional<NormalizedConstraint>{};
       }
-      ParameterMapping = cast<ConceptSpecializationExpr>(Result.get())
+      Mapping = cast<ConceptSpecializationExpr>(Result.get())
                            ->getTemplateArgsAsWritten();
 
-      TemplateArgumentListInfo SubstTALI(ParameterMapping->LAngleLoc,
-                                         ParameterMapping->RAngleLoc);
-      for (auto &Arg : ParameterMapping->arguments())
+      TemplateArgumentListInfo SubstTALI(Mapping->LAngleLoc,
+                                         Mapping->RAngleLoc);
+      for (auto &Arg : Mapping->arguments())
         SubstTALI.addArgument(Arg);
       llvm::SmallVector<TemplateArgument, 4> Converted;
+      bool InstantiationDependent;
       bool Failure = S.CheckTemplateArgumentList(
           CSE->getNamedConcept(), CSE->getBeginLoc(), SubstTALI,
           /*PartialTemplateArgs=*/false, Converted,
           /*UpdateArgsWithConversions=*/true, &InstantiationDependent);
+      MultiLevelTemplateArgumentList MLTAL;
+      MLTAL.addOuterTemplateArguments(Converted);
+
       // The case is this:
       //
       // template<typename T, typename U>
       // concept C1 = true;
       //
       // template<typename... Ts>
       // concept C2 = C1<Ts...>; // After substituting Ts = {T}, the
       //                         // resulting argument list does not match
if (auto *BO = dyn_cast<const BinaryOperator>(E)) {
         // concept C2 = C1<Us...>; // After substituting Us = {Ts}, we cannot
         //                         // match arguments to parameters.
         //
         // template<typename... Ts>
         // void foo() requires C2<T...> {}
         //
         // Treat the CSE as an atomic expression.
         return NormalizedConstraint{new (S.Context)
-                                        AtomicConstraint(E, ParameterMapping)};
+                                        AtomicConstraint(E, Converted)};
 
       return fromConstraintExpr(S, CSE->getNamedConcept()->getConstraintExpr(),
-                                CSE->getNamedConcept(), ParameterMapping);
+                                &MLTAL);
     }
-    return NormalizedConstraint{new (S.Context)
-                                    AtomicConstraint(E, ParameterMapping)};
+    return NormalizedConstraint{
+        new (S.Context) AtomicConstraint(E,
+            ParameterMapping && ParameterMapping->getNumLevels() != 0 ?
+            ParameterMapping->getInnermost() : ArrayRef<TemplateArgument>{})};
   }
 
   static llvm::Optional<NormalizedConstraint> fromConstraintExprs(Sema &S,
-      ArrayRef<const Expr *> E) {
+      ArrayRef<const Expr *> E,
+      const MultiLevelTemplateArgumentList *ParameterMapping = nullptr) {
     assert(E.size() != 0);
-    auto First = fromConstraintExpr(S, E[0]);
+    auto First = fromConstraintExpr(S, E[0], ParameterMapping);
     if (E.size() == 1)
       return First;
-    auto Second = fromConstraintExpr(S, E[1]);
+    auto Second = fromConstraintExpr(S, E[1], ParameterMapping);
     if (!Second)
       return llvm::Optional<NormalizedConstraint>{};
     llvm::Optional<NormalizedConstraint> Conjunction;
     Conjunction.emplace(S.Context, std::move(*First), std::move(*Second),
                         CCK_Conjunction);
     for (unsigned I = 2; I < E.size(); ++I) {
-      auto Next = fromConstraintExpr(S, E[I]);
+      auto Next = fromConstraintExpr(S, E[I], ParameterMapping);
       if (!Next)
         return llvm::Optional<NormalizedConstraint>{};
       NormalizedConstraint NewConjunction(S.Context, std::move(*Conjunction),
                                           std::move(*Next), CCK_Conjunction);
       *Conjunction = std::move(NewConjunction);
     }
     return Conjunction;
   }
for (auto &RConjunction : RDNF) {
                 std::back_inserter(Combined));
       Res.emplace_back(Combined);
     }
   }
   return Res;
 }
 
 template<typename AtomicSubsumptionEvaluator>
-static bool subsumes(Sema &S, ArrayRef<const Expr *> P,
-                     ArrayRef<const Expr *> Q, bool &DoesSubsume,
+static bool subsumes(Sema &S, NormalizedConstraint &PNormalized,
+                     NormalizedConstraint &QNormalized, bool &DoesSubsume,
                      AtomicSubsumptionEvaluator E) {
   // C++ [temp.constr.order] p2
   //   In order to determine if a constraint P subsumes a constraint Q, P is
   //   transformed into disjunctive normal form, and Q is transformed into
   //   conjunctive normal form. [...]
-  auto PNormalized = NormalizedConstraint::fromConstraintExprs(S, P);
-  if (!PNormalized)
-    return true;
-  const NormalForm PDNF = makeDNF(*PNormalized);
-
-  auto QNormalized = NormalizedConstraint::fromConstraintExprs(S, Q);
-  if (!QNormalized)
-    return true;
-  const NormalForm QCNF = makeCNF(*QNormalized);
+  const NormalForm PDNF = makeDNF(PNormalized);
+  const NormalForm QCNF = makeCNF(QNormalized);
 
   // C++ [temp.constr.order] p2
   //   Then, P subsumes Q if and only if, for every disjunctive clause Pi in the
   //   disjunctive normal form of P, Pi subsumes every conjunctive clause Qj in
   //   the conjuctive normal form of Q, where [...]
   for (const auto &Pi : PDNF) {
     for (const auto &Qj : QCNF) {
       // C++ [temp.constr.order] p2
for (const auto &Qj : QCNF) {
       }
     }
   }
   DoesSubsume = true;
   return false;
 }
 
 bool Sema::IsAtLeastAsConstrained(NamedDecl *D1, ArrayRef<const Expr *> AC1,
-                                  NamedDecl *D2, ArrayRef<const Expr *> AC2,
-                                  bool NoCache) {
+                                  NamedDecl *D2, ArrayRef<const Expr *> AC2) {
   if (AC1.empty())
     return AC2.empty();
   if (AC2.empty())
     // TD1 has associated constraints and TD2 does not.
     return true;
 
   std::pair<NamedDecl *, NamedDecl *> Key{D1, D2};
-  if (!NoCache) {
-    auto CacheEntry = SubsumptionCache.find(Key);
-    if (CacheEntry != SubsumptionCache.end())
-      return CacheEntry->second;
-  }
+
+  MultiLevelTemplateArgumentList MLTAL1 =
+      getTemplateInstantiationArgs(cast<Decl>(D1->getDeclContext()));
+  MultiLevelTemplateArgumentList MLTAL2 =
+      getTemplateInstantiationArgs(cast<Decl>(D2->getDeclContext()));
+  bool Subsumes = IsAtLeastAsConstrained(AC1, MLTAL1, AC2, MLTAL2);
+  SubsumptionCache.try_emplace(Key, Subsumes);
+  return Subsumes;
 
+bool
+Sema::IsAtLeastAsConstrained(ArrayRef<const Expr *> AC1,
+                             const MultiLevelTemplateArgumentList &MLTAL1,
+                             ArrayRef<const Expr *> AC2,
+                             const MultiLevelTemplateArgumentList &MLTAL2) {
+  if (AC1.empty())
+    return AC2.empty();
+  if (AC2.empty())
+    // TD1 has associated constraints and TD2 does not.
+    return true;
+
+  auto Normalized1 = NormalizedConstraint::fromConstraintExprs(*this, AC1,
+                                                               &MLTAL1);
+  if (!Normalized1)
+    // Program is ill-formed at this point.
+    return false;
+
+  auto Normalized2 = NormalizedConstraint::fromConstraintExprs(*this, AC2,
+                                                               &MLTAL2);
+  if (!Normalized2)
+    // Program is ill-formed at this point.
+    return false;
+
   bool Subsumes;
-  if (subsumes(*this, AC1, AC2, Subsumes,
+  if (subsumes(*this, *Normalized1, *Normalized2, Subsumes,
         [this] (const AtomicConstraint &A, const AtomicConstraint &B) {
           return A.subsumes(Context, B);
         }))
     // Program is ill-formed at this point.
     return false;
-  if (!NoCache)
-    SubsumptionCache.try_emplace(Key, Subsumes);
   return Subsumes;
 }
 
 bool Sema::MaybeEmitAmbiguousAtomicConstraintsDiagnostic(NamedDecl *D1,
-    ArrayRef<const Expr *> AC1, NamedDecl *D2, ArrayRef<const Expr *> AC2) {
+    ArrayRef<const Expr *> AC1, const MultiLevelTemplateArgumentList &MLTAL1,
+    NamedDecl *D2, ArrayRef<const Expr *> AC2,
+    const MultiLevelTemplateArgumentList &MLTAL2) {
   if (AC1.empty() || AC2.empty())
     return false;
 
   auto NormalExprEvaluator =
       [this] (const AtomicConstraint &A, const AtomicConstraint &B) {
         return A.subsumes(Context, B);
       };
 
auto IdenticalExprEvaluator =
         AmbiguousAtomic1 = EA;
         AmbiguousAtomic2 = EB;
         return true;
       };
 
   {
     // The subsumption checks might cause diagnostics
     SFINAETrap Trap(*this);
+
+    auto Normalized1 = NormalizedConstraint::fromConstraintExprs(*this, AC1,
+                                                                 &MLTAL1);
+    if (!Normalized1)
+      // Program is ill-formed at this point.
+      return false;
+
+    auto Normalized2 = NormalizedConstraint::fromConstraintExprs(*this, AC2,
+                                                                 &MLTAL2);
+    if (!Normalized2)
+      // Program is ill-formed at this point.
+      return false;
+
     bool Is1AtLeastAs2Normally, Is2AtLeastAs1Normally;
-    if (subsumes(*this, AC1, AC2, Is1AtLeastAs2Normally, NormalExprEvaluator))
+    if (subsumes(*this, *Normalized1, *Normalized2, Is1AtLeastAs2Normally,
+                 NormalExprEvaluator))
       return false;
-    if (subsumes(*this, AC2, AC1, Is2AtLeastAs1Normally, NormalExprEvaluator))
+    if (subsumes(*this, *Normalized2, *Normalized1, Is2AtLeastAs1Normally,
+                 NormalExprEvaluator))
       return false;
     bool Is1AtLeastAs2, Is2AtLeastAs1;
-    if (subsumes(*this, AC1, AC2, Is1AtLeastAs2, IdenticalExprEvaluator))
+    if (subsumes(*this, *Normalized1, *Normalized2, Is1AtLeastAs2,
+                 IdenticalExprEvaluator))
       return false;
-    if (subsumes(*this, AC2, AC1, Is2AtLeastAs1, IdenticalExprEvaluator))
+    if (subsumes(*this, *Normalized2, *Normalized1, Is2AtLeastAs1,
+                 IdenticalExprEvaluator))
       return false;
     if (Is1AtLeastAs2 == Is1AtLeastAs2Normally &&
         Is2AtLeastAs1 == Is2AtLeastAs1Normally)
       // Same result - no ambiguity was caused by identical atomic expressions.
       return false;
   }
 
   // A different result! Some ambiguous atomic constraint(s) caused a difference
   assert(AmbiguousAtomic1 && AmbiguousAtomic2);
 
   Diag(AmbiguousAtomic1->getBeginLoc(), diag::note_ambiguous_atomic_constraints)
       << const_cast<Expr *>(AmbiguousAtomic1)
       << AmbiguousAtomic1->getSourceRange();
   Diag(AmbiguousAtomic2->getBeginLoc(),
        diag::note_ambiguous_atomic_constraints_second)
       << AmbiguousAtomic2->getSourceRange();
   return true;
 }
 
+bool Sema::MaybeEmitAmbiguousAtomicConstraintsDiagnostic(NamedDecl *D1,
+    ArrayRef<const Expr *> AC1, NamedDecl *D2, ArrayRef<const Expr *> AC2) {
+  if (AC1.empty() || AC2.empty())
+    return false;
+  MultiLevelTemplateArgumentList MLTAL1 =
+      getTemplateInstantiationArgs(cast<Decl>(D1->getDeclContext()));
+  MultiLevelTemplateArgumentList MLTAL2 =
+      getTemplateInstantiationArgs(cast<Decl>(D2->getDeclContext()));
+  return MaybeEmitAmbiguousAtomicConstraintsDiagnostic(D1, AC1, MLTAL1, D2, AC2,
+                                                       MLTAL2);
+}
 
 
 ExprRequirement::ExprRequirement(Sema &S, Expr *E, bool IsSimple,
                                  SourceLocation NoexceptLoc,
                                  ReturnTypeRequirement Req) :
     Requirement(IsSimple ? RK_Simple : RK_Compound,
                 E->isInstantiationDependent() || Req.isDependent(),
                 E->containsUnexpandedParameterPack() ||
case SS_SubstitutionFailure: {
     return;
   }
   default:
     llvm_unreachable("Unknown satisfaction status");
     return;
   }
 }
 
-NestedRequirement::NestedRequirement(Sema &S, Expr *Constraint) :
-    Requirement(RK_Nested, Constraint->isInstantiationDependent(),
-                Constraint->containsUnexpandedParameterPack(),
-                /*Satisfied=*/false), Value(Constraint) {
-  if (isDependent())
-    return;
+NestedRequirement::NestedRequirement(Sema &S, Expr *Constraint,
+    const MultiLevelTemplateArgumentList &TemplateArgs) :
+    Requirement(RK_Nested,
+                /*(set below)Dependent=*/false,
+                /*(set below)ContainsUnexpandedParameterPack=*/false,
+                /*(set below)Satisfied=*/false), ConstraintExpr(Constraint) {
+  if (TemplateArgs.getNumLevels() == 0)
     S.CheckConstraintSatisfaction(Constraint, Satisfaction);
+  else {
+    bool IsDependent, ContainsUnexpandedParameterPack;
+    S.CheckConstraintSatisfaction(this, Constraint, TemplateArgs,
+        Satisfaction, IsDependent, ContainsUnexpandedParameterPack);
+    setDependent(IsDependent);
+    setContainsUnexpandedParameterPack(ContainsUnexpandedParameterPack);
+  }
   setSatisfied(Satisfaction.IsSatisfied);
 }
 
 void NestedRequirement::Diagnose(Sema &S, bool First) const {
-  if (isSubstitutionFailure()) {
-    auto *SubstDiag = getSubstitutionDiagnostic();
-    if (!SubstDiag->DiagMessage.empty())
-      S.Diag(SubstDiag->DiagLoc,
-             diag::note_nested_requirement_substitution_error) << (int)First
-          << SubstDiag->SubstitutedEntity << SubstDiag->DiagMessage;
-    else
-      S.Diag(SubstDiag->DiagLoc,
-             diag::note_nested_requirement_unknown_substitution_error)
-          << (int)First << SubstDiag->SubstitutedEntity;
-    return;
-  }
   S.DiagnoseUnsatisfiedConstraint(Satisfaction, First);
 }
 No newline at end of file

lib/Sema/SemaExpr.cpp

bool Sema::DiagnoseUseOfDecl(NamedDecl *D, ArrayRef<SourceLocation> Locs,
 
   // [expr.prim.id]p4
   //   A program that refers explicitly or implicitly to a function with a
   //   trailing requires-clause whose constraint-expression is not satisfied,
   //   other than to declare it, is ill-formed. [...]
   //
   // See if this is a function with constraints that need to be satisfied.
   if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
-    if (Expr *RC = FD->getTrailingRequiresClause()) {
-      ConstraintSatisfaction Satisfaction;
-      bool Failed = CheckConstraintSatisfaction(RC, Satisfaction);
-      if (Failed)
-        // A diagnostic will have already been generated (non-constant
-        // constraint expression, for example)
-        return true;
-      if (!Satisfaction.IsSatisfied) {
-        Diag(Loc,
-             diag::err_reference_to_function_with_unsatisfied_constraints)
-            << D;
-        DiagnoseUnsatisfiedConstraint(Satisfaction);
-        return true;
-      }
-    }
-  }
+    bool Failed = CheckFunctionConstraints(FD, Satisfaction);
+           diag::err_reference_to_function_with_unsatisfied_constraints) << D;
 
   return false;
 }
 
 /// DiagnoseSentinelCalls - This routine checks whether a call or
 /// message-send is to a declaration with the sentinel attribute, and
 /// if so, it checks that the requirements of the sentinel are
 /// satisfied.

lib/Sema/SemaExprCXX.cpp

 #include "clang/Lex/Preprocessor.h"
 #include "clang/Sema/DeclSpec.h"
 #include "clang/Sema/Initialization.h"
 #include "clang/Sema/Lookup.h"
 #include "clang/Sema/ParsedTemplate.h"
 #include "clang/Sema/Scope.h"
 #include "clang/Sema/ScopeInfo.h"
 #include "clang/Sema/SemaLambda.h"
+#include "clang/Sema/Template.h"
 #include "clang/Sema/TemplateDeduction.h"
 #include "llvm/ADT/APInt.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/Support/ErrorHandling.h"
 using namespace clang;
 using namespace sema;
 
 /// Handle the result of the special case name lookup for inheriting
Sema::ActOnCompoundRequirement(Expr *E, SourceLocation NoexceptLoc,
 
   return new (Context) ExprRequirement(*this, E, /*IsSimple=*/false,
       NoexceptLoc,
       ExprRequirement::ReturnTypeRequirement(Context, TPL,
           GetTypeForDeclarator(DeducedDeclarator, CurScope)));
 }
 
 Requirement *Sema::ActOnNestedRequirement(Expr *Constraint) {
-  return new (Context) NestedRequirement(*this, Constraint);
+  if (!Constraint->isInstantiationDependent())
+    return new (Context) NestedRequirement(*this, Constraint,
+        MultiLevelTemplateArgumentList());
+  return new (Context) NestedRequirement(Constraint);
 }
 
 RequiresExprBodyDecl *
 Sema::ActOnEnterRequiresExpr(SourceLocation RequiresKWLoc,
                              ArrayRef<ParmVarDecl *> LocalParameters,
                              Scope *BodyScope) {
   assert(BodyScope);
 
Sema::CreateRequiresExpr(SourceLocation RequiresKWLoc,
                          RequiresExprBodyDecl *Body,
                          ArrayRef<ParmVarDecl *> LocalParameters,
                          ArrayRef<Requirement *> Requirements,
                          SourceLocation ClosingBraceLoc) {
   return new (Context) RequiresExpr(Context, RequiresKWLoc, Body,
                                     LocalParameters, Requirements,
                                     ClosingBraceLoc);
 }
 No newline at end of file

lib/Sema/SemaOverload.cpp

if (const FunctionDecl *Caller = dyn_cast<FunctionDecl>(CurContext))
       // inferred for the member automatically, based on the bases and fields of
       // the class.
       if (!Caller->isImplicit() && !IsAllowedCUDACall(Caller, Function)) {
         Candidate.Viable = false;
         Candidate.FailureKind = ovl_fail_bad_target;
         return;
       }
 
-  Expr *RequiresClause = Function->getTrailingRequiresClause();
-  if (LangOpts.ConceptsTS && RequiresClause) {
+  if (LangOpts.ConceptsTS) {
     ConstraintSatisfaction Satisfaction;
-    if (CheckConstraintSatisfaction(RequiresClause, Satisfaction) ||
+    if (CheckFunctionConstraints(Function, Satisfaction) ||
         !Satisfaction.IsSatisfied) {
       Candidate.Viable = false;
       Candidate.FailureKind = ovl_fail_constraints_not_satisfied;
       return;
     }
   }
 
   // Determine the implicit conversion sequences for each of the
Sema::AddMethodCandidate(CXXMethodDecl *Method, DeclAccessPair FoundDecl,
   if (getLangOpts().CUDA)
     if (const FunctionDecl *Caller = dyn_cast<FunctionDecl>(CurContext))
       if (!IsAllowedCUDACall(Caller, Method)) {
         Candidate.Viable = false;
         Candidate.FailureKind = ovl_fail_bad_target;
         return;
       }
 
-  Expr *RequiresClause = Method->getTrailingRequiresClause();
-  if (LangOpts.ConceptsTS && RequiresClause) {
+  if (LangOpts.ConceptsTS) {
     ConstraintSatisfaction Satisfaction;
-    if (CheckConstraintSatisfaction(RequiresClause, Satisfaction) ||
+    if (CheckFunctionConstraints(Method, Satisfaction) ||
         !Satisfaction.IsSatisfied) {
       Candidate.Viable = false;
       Candidate.FailureKind = ovl_fail_constraints_not_satisfied;
       return;
     }
   }
 
   // Determine the implicit conversion sequences for each of the
Candidate.Conversions[0] = TryObjectArgumentInitialization(
       From->Classify(Context), Conversion, ConversionContext);
 
   if (Candidate.Conversions[0].isBad()) {
     Candidate.Viable = false;
     Candidate.FailureKind = ovl_fail_bad_conversion;
     return;
   }
 
-  Expr *RequiresClause = Conversion->getTrailingRequiresClause();
-  if (LangOpts.ConceptsTS && RequiresClause) {
+  if (LangOpts.ConceptsTS) {
     ConstraintSatisfaction Satisfaction;
-    if (CheckConstraintSatisfaction(RequiresClause, Satisfaction) ||
+    if (CheckFunctionConstraints(Conversion, Satisfaction) ||
         !Satisfaction.IsSatisfied) {
       Candidate.Viable = false;
       Candidate.FailureKind = ovl_fail_constraints_not_satisfied;
       return;
     }
   }
 
   // We won't go through a user-defined type conversion function to convert a
if (Complain) {
         S.Diag(FD->getBeginLoc(),
                diag::note_addrof_ovl_candidate_disabled_by_enable_if_attr);
       else
         S.Diag(Loc, diag::err_addrof_function_disabled_by_enable_if_attr) << FD;
     }
     return false;
   }
 
-  if (const Expr *RC = FD->getTrailingRequiresClause()) {
-    ConstraintSatisfaction Satisfaction;
-    if (S.CheckConstraintSatisfaction(RC, Satisfaction))
-      return false;
-    if (!Satisfaction.IsSatisfied) {
-      if (Complain) {
-        if (InOverloadResolution)
-          S.Diag(FD->getBeginLoc(),
-                 diag::note_ovl_candidate_unsatisfied_constraints);
-        else
-          S.Diag(Loc, diag::err_addrof_function_constraints_not_satisfied)
-              << FD;
-        S.DiagnoseUnsatisfiedConstraint(Satisfaction);
-      }
-      return false;
-    }
-  }
+  if (S.CheckFunctionConstraints(const_cast<FunctionDecl *>(FD), Satisfaction))
 
   auto I = llvm::find_if(FD->parameters(), [](const ParmVarDecl *P) {
     return P->hasAttr<PassObjectSizeAttr>();
   });
   if (I == FD->param_end())
     return true;
 
   if (Complain) {
static void NoteFunctionCandidate(Sema &S, OverloadCandidate *Cand,
   case ovl_fail_constraints_not_satisfied: {
     std::string Description;
     OverloadCandidateKind FnKind =
            ClassifyOverloadCandidate(S, Cand->FoundDecl, Fn, Description).first;
     S.Diag(Fn->getLocation(),
            diag::note_ovl_candidate_constraints_not_satisfied)
             << (unsigned) FnKind;
     ConstraintSatisfaction Satisfaction;
-    if (S.CheckConstraintSatisfaction(Fn->getTrailingRequiresClause(),
-                                      Satisfaction))
+    if (S.CheckFunctionConstraints(Fn, Satisfaction))
       break;
     S.DiagnoseUnsatisfiedConstraint(Satisfaction);
   }
   }
 }
 
 static void NoteSurrogateCandidate(Sema &S, OverloadCandidate *Cand) {
   // Desugar the type of the surrogate down to a function type,
void TemplateSpecCandidateSet::NoteCandidates(Sema &S, SourceLocation Loc) {
   if (I != E)
     S.Diag(Loc, diag::note_ovl_too_many_candidates) << int(E - I);
 
   MaybeDiagnoseAmbiguousConstraints(S, Cands.begin(), E,
       [] (const TemplateSpecCandidate *Cand)
           -> std::pair<NamedDecl *, llvm::SmallVector<const Expr *, 3>> {
         if (Cand->Specialization)
           if (FunctionDecl *FD = dyn_cast<FunctionDecl>(Cand->Specialization))
-            if (TemplateDecl *TD = FD->getPrimaryTemplate())
+            if (auto *TD = FD->getPrimaryTemplate())
               return { FD, TD->getAssociatedConstraints() };
         return { nullptr, {} };
       });
 }
 
 // [PossiblyAFunctionType]  -->   [Return]
 // NonFunctionType --> NonFunctionType
 // R (A) --> R(A)

lib/Sema/SemaTemplate.cpp

if (OldParams &&
                                          &OldMismatch, &NewMismatch)){
     DiagnoseRedeclarationConstraintMismatch(OldMismatch ?
                                             OldMismatch->getBeginLoc() :
                                             OldParams->getTemplateLoc(),
                                             NewMismatch ?
                                             NewMismatch->getBeginLoc() :
                                             NewParams->getTemplateLoc());
     Invalid = true;
+  } else if (OldParams && NewParams->hasAssociatedConstraints()) {
+    if (NewParams->getRequiresClause())
+      NewParams->setInheritedConstraints(OldParams);
+    for (unsigned I = 0, C = NewParams->size(); I != C; ++I) {
+      auto *NewParam = (*NewParams).getParam(I);
+      auto *OldParam = (*OldParams).getParam(I);
+      if (auto *NewTTP = dyn_cast<TemplateTypeParmDecl>(NewParam))
+        NewTTP->setInheritedConstraintExpression(
+                                          cast<TemplateTypeParmDecl>(OldParam));
+      else if (auto *NewNTTP = dyn_cast<NonTypeTemplateParmDecl>(NewParam))
+        NewNTTP->setInheritedConstraintExpression(
+                                       cast<NonTypeTemplateParmDecl>(OldParam));
+      else
+        cast<TemplateTemplateParmDecl>(NewParam)->
+            setInheritedConstraintExpression(
+                                      cast<TemplateTemplateParmDecl>(OldParam));
+    }
   }
 
   bool RemoveDefaultArguments = false;
   for (TemplateParameterList::iterator NewParam = NewParams->begin(),
                                     NewParamEnd = NewParams->end();
        NewParam != NewParamEnd; ++NewParam) {
     // Variables used to diagnose redundant default arguments
     bool RedundantDefaultArg = false;
Sema::CheckConceptTemplateId(const CXXScopeSpec &SS,
   ConstraintSatisfaction Satisfaction;
   bool IsInstantiationDependent = false;
   for (TemplateArgument &Arg : Converted) {
     if (Arg.isInstantiationDependent()) {
       IsInstantiationDependent = true;
       break;
     }
   }
-  if (!IsInstantiationDependent)
+  if (!IsInstantiationDependent) {
+    TemplateArgumentList TempList(TemplateArgumentList::OnStack, Converted);
     if (CheckConstraintSatisfaction(NamedConcept,
                                     {NamedConcept->getConstraintExpr()},
-                                    Converted,
+                                    MultiLevelTemplateArgumentList(TempList),
                                     SourceRange(SS.isSet() ? SS.getBeginLoc() :
                                                              ConceptNameLoc,
                                                 TemplateArgs->getRAngleLoc()),
                                     Satisfaction))
       return ExprError();
+  }
 
   return ConceptSpecializationExpr::Create(Context,
       SS.isSet() ? SS.getWithLocInContext(Context) : NestedNameSpecifierLoc{},
       TemplateKWLoc, ConceptNameLoc, FoundDecl, NamedConcept,
       ASTTemplateArgumentListInfo::Create(Context, *TemplateArgs), Converted,
       std::move(Satisfaction));
 }
 
bool Sema::CheckTemplateArgument(NamedDecl *Param,
   }
 
   switch (Arg.getArgument().getKind()) {
   case TemplateArgument::Null:
     llvm_unreachable("Should never see a NULL template argument here");
 
   case TemplateArgument::Template:
   case TemplateArgument::TemplateExpansion:
-    if (CheckTemplateTemplateArgument(TempParm, Params, Arg))
+    if (CheckTemplateArgument(TempParm, Params, Arg, ArgumentPackIndex,
+                              Converted))
       return true;
 
     Converted.push_back(Arg.getArgument());
     break;
 
   case TemplateArgument::Expression:
   case TemplateArgument::Type:
     // We have a template template parameter but the template
static void DiagnoseTemplateParameterListArityMismatch(
     Sema &S, TemplateParameterList *New, TemplateParameterList *Old,
     Sema::TemplateParameterListEqualKind Kind, SourceLocation TemplateArgLoc);
 
 /// Check a template argument against its corresponding
 /// template template parameter.
 ///
 /// This routine implements the semantics of C++ [temp.arg.template].
 /// It returns true if an error occurred, and false otherwise.
-bool Sema::CheckTemplateTemplateArgument(TemplateTemplateParmDecl *Param,
-                                         TemplateParameterList *Params,
-                                         TemplateArgumentLoc &Arg) {
+bool Sema::CheckTemplateArgument(TemplateTemplateParmDecl *Param,
+                                 TemplateArgumentLoc &Arg,
+                                 unsigned ArgumentPackIndex,
+                                 ArrayRef<TemplateArgument> Converted) {
   TemplateName Name = Arg.getArgument().getAsTemplateOrTemplatePattern();
   TemplateDecl *Template = Name.getAsTemplateDecl();
   if (!Template) {
     // Any dependent template name is fine.
     assert(Name.isDependent() && "Non-dependent template isn't a declaration?");
     return false;
   }
 
if (TemplateParameterListsAreEqual(
         // If the argument has no associated constraints, then the parameter is
         // definitely at least as specialized as the argument.
         // Otherwise - we need a more thorough check.
         !Template->hasAssociatedConstraints())
       return false;
 
     if (isTemplateTemplateParameterAtLeastAsSpecializedAs(Params, Template,
                                                           Arg.getLocation())) {
+      TemplateArgumentList ParamsSoFar(TemplateArgumentList::OnStack,
+                                       Converted);
+      // We want the enclosing template arguments along with the template
+      // arguments provided thus far in this template parameter list:
+      //
+      // template<typename T>
+      // struct A {
+      //   template<typename U, template<T t, U u> class TT> struct B { };
+      // };
+      // In the above example, for checking TT, we'll need:
+      // ParamMLTAL:
+      //   Depth 0: <T>
+      //   Depth 1: <U>
+      DeclContext *TemplatedEntityParent = Param->getDeclContext()->getParent();
+      MultiLevelTemplateArgumentList ParamMLTAL =
+          getTemplateInstantiationArgs(cast<Decl>(TemplatedEntityParent),
+                                       /*Innermost=*/&ParamsSoFar);
+      MultiLevelTemplateArgumentList ArgMLTAL =
+          getTemplateInstantiationArgs(Template);
       // C++2a[temp.func.order]p2
       //   [...] If both deductions succeed, the partial ordering selects the
       //   more constrained template as described by the rules in
       //   [temp.constr.order].
-      if (!IsAtLeastAsConstrained(Param, Params->getAssociatedConstraints(),
-                                  Template,
+      if (!IsAtLeastAsConstrained(Params->getAssociatedConstraints(),
+                                  ParamMLTAL,
                                   Template->getAssociatedConstraints(),
-                                  /*NoCache=*/true)) {
+                                  ArgMLTAL)) {
         Diag(Arg.getLocation(),
              diag::err_template_template_parameter_not_at_least_as_constrained)
             << Template << Param << Arg.getSourceRange();
         Diag(Param->getLocation(), diag::note_entity_declared_at) << Param;
         Diag(Template->getLocation(), diag::note_entity_declared_at)
             << Template;
         MaybeEmitAmbiguousAtomicConstraintsDiagnostic(Param,
-            Params->getAssociatedConstraints(), Template,
-            Template->getAssociatedConstraints());
+            Params->getAssociatedConstraints(), ParamMLTAL, Template,
+            Template->getAssociatedConstraints(), ArgMLTAL);
         return true;
       }
       return false;
     }
     // FIXME: Produce better diagnostics for deduction failures.
   }
 
   return !TemplateParameterListsAreEqual(Template->getTemplateParameters(),

lib/Sema/SemaTemplateDeduction.cpp

struct IsPartialSpecialization<VarTemplatePartialSpecializationDecl> {
   static constexpr bool value = true;
 };
 
 template<typename TemplateDeclT>
 static Sema::TemplateDeductionResult
 CheckDeducedArgumentConstraints(Sema& S, TemplateDeclT *Template,
                                 ArrayRef<TemplateArgument> DeducedArgs,
                                 TemplateDeductionInfo& Info) {
+  TemplateArgumentList TAL(TemplateArgumentList::OnStack, DeducedArgs);
+  DeclContext *DC = Template->getDeclContext();
+  MultiLevelTemplateArgumentList MLTAL;
+  if (NamedDecl *ND = dyn_cast<NamedDecl>(DC))
+    MLTAL = S.getTemplateInstantiationArgs(ND, /*Innermost=*/&TAL);
+  else
+    MLTAL.addOuterTemplateArguments(&TAL);
   if (S.CheckConstraintSatisfaction(Template,
                                     Template->getAssociatedConstraints(),
-                                    DeducedArgs, Info.getLocation(),
+                                    MLTAL, Info.getLocation(),
                                     Info.AssociatedConstraintsSatisfaction)
       || !Info.AssociatedConstraintsSatisfaction.IsSatisfied) {
     Info.reset(TemplateArgumentList::CreateCopy(S.Context, DeducedArgs));
     return Sema::TDK_ConstraintsNotSatisfied;
   }
   return Sema::TDK_Success;
 }
 
Sema::TemplateDeductionResult Sema::FinishTemplateArgumentDeduction(
   // C++2a [temp.deduct]p5
   //   [...] When all template arguments have been deduced [...] all uses of
   //   template parameters [...] are replaced with the corresponding deduced
   //   or default argument values.
   //   [...] If the function template has associated constraints
   //   ([temp.constr.decl]), those constraints are checked for satisfaction
   //   ([temp.constr.constr]). If the constraints are not satisfied, type
   //   deduction fails.
-  if (CheckInstantiatedFunctionTemplateConstraints(Info.getLocation(),
-          Specialization, Builder, Info.AssociatedConstraintsSatisfaction))
+  if (CheckFunctionConstraints(Specialization,
+                               Info.AssociatedConstraintsSatisfaction))
     return TDK_MiscellaneousDeductionFailure;
 
   if (!Info.AssociatedConstraintsSatisfaction.IsSatisfied) {
     Info.reset(TemplateArgumentList::CreateCopy(Context, Builder));
     return TDK_ConstraintsNotSatisfied;
   }
 
   if (OriginalCallArgs) {
Sema::DeduceAutoType(TypeLoc Type, Expr *&Init, QualType &Result,
   LocalInstantiationScope InstScope(*this);
 
   // Build template<class TemplParam> void Func(FuncParam);
   TemplateTypeParmDecl *TemplParam = TemplateTypeParmDecl::Create(
       Context, nullptr, SourceLocation(), Loc, Depth, 0, nullptr, false, false);
   QualType TemplArg = QualType(TemplParam->getTypeForDecl(), 0);
   NamedDecl *TemplParamPtr = TemplParam;
   FixedSizeTemplateParameterListStorage<1, false> TemplateParamsSt(
-      Context, Loc, Loc, TemplParamPtr, Loc, nullptr);
+      Context, Loc, Loc, TemplParamPtr, Loc, nullptr, nullptr);
 
   QualType FuncParam =
       SubstituteDeducedTypeTransform(*this, TemplArg, /*UseTypeSugar*/false)
           .Apply(Type);
   assert(!FuncParam.isNull() &&
          "substituting template parameter for 'auto' failed");
 
   // Deduce type of TemplParam in Func(Init)
OriginalCallArgs.push_back(OriginalCallArg(ParamType,
                                              /*DecomposedParam=*/false,
                                              /*ArgIdx=*/0, Arg->getType()));
   TemplateDeductionInfo Info{SourceLocation(), TemplateParams->getDepth()};
   auto Result = ::DeduceTemplateArgumentsFromCallArgument(*this, TemplateParams,
       /*FirstInnerIndex=*/0, ParamType, Arg, Info, Deduced,  OriginalCallArgs,
       /*DecomposedParam=*/false, /*ArgIdx=*/0, /*TDF=*/0);
   return Result == TDK_Success ? Deduced[0].getAsType() : QualType();
 }
 No newline at end of file

lib/Sema/SemaTemplateInstantiate.cpp

 /// dealing with a specialization. This is only relevant for function
 /// template specializations.
 ///
 /// \param Pattern If non-NULL, indicates the pattern from which we will be
 /// instantiating the definition of the given declaration, \p D. This is
 /// used to determine the proper set of template instantiation arguments for
 /// friend function template specializations.
 MultiLevelTemplateArgumentList
-Sema::getTemplateInstantiationArgs(NamedDecl *D,
+Sema::getTemplateInstantiationArgs(Decl *D,
                                    const TemplateArgumentList *Innermost,
                                    bool RelativeToPrimary,
                                    const FunctionDecl *Pattern) {
   // Accumulate the set of template argument lists in this structure.
   MultiLevelTemplateArgumentList Result;
 
   if (Innermost)
     Result.addOuterTemplateArguments(Innermost);
if (!Invalid) {
     atTemplateEnd(SemaRef.TemplateInstCallbacks, SemaRef,
                   SemaRef.CodeSynthesisContexts.back());
 
     SemaRef.popCodeSynthesisContext();
     Invalid = true;
   }
 }
 
+Sema::
+InstantiatingTemplate::InstantiatingTemplate(InstantiatingTemplate &&Other) :
+  SemaRef(Other.SemaRef), Invalid(Other.Invalid),
+  AlreadyInstantiating(Other.AlreadyInstantiating) {
+  Other.Invalid = true;
+}
+
 bool Sema::InstantiatingTemplate::CheckInstantiationDepth(
                                         SourceLocation PointOfInstantiation,
                                            SourceRange InstantiationRange) {
   assert(SemaRef.NonInstantiationEntries <=
          SemaRef.CodeSynthesisContexts.size());
   if ((SemaRef.CodeSynthesisContexts.size() -
           SemaRef.NonInstantiationEntries)
         <= SemaRef.getLangOpts().InstantiationDepth)
else
       TransRetReq.emplace(SemaRef.Context, TransType);
   } else if (RetReq.isConstrainedParameter()) {
     TemplateParameterList *OrigTPL =
         RetReq.getConstrainedParamTemplateParameterList();
     Sema::InstantiatingTemplate TPLInst(SemaRef, OrigTPL->getTemplateLoc(),
                                         Req, Info, OrigTPL->getSourceRange());
     if (TPLInst.isInvalid())
       return nullptr;
+
+    // C++ [expr.prim.req.compound]p1.3.3
+    //    [...] the expression is deduced against an invented function template
+    //    F using the rules in 17.8.2.1. F is a void function template with a
+    //    single type template parameter T declared with the
+    //    constrained-parameter.
+
+    // This will not instantiate the requires clause, because in any other
+    // context where instantiating TPLs, we are required by the standard not to
+    // instantiate the requires clause, but here this TPL's constraint is
+    // in fact only formed standard-wise while checking for the satisfaction -
+    // when forming the invented template parameter F, therefore we must
+    // substitute into it here.
+
     TemplateParameterList *TPL =
         TransformTemplateParameterList(OrigTPL);
-    if (!TPL)
+    assert(TPL != nullptr);
+    ExprResult SubstConstraint = TransformExpr(OrigTPL->getRequiresClause());
+    if (SubstConstraint.isInvalid())
       TransRetReq.emplace(createSubstDiag(SemaRef, Info,
           [&] (llvm::raw_string_ostream& OS) {
               OrigTPL->getRequiresClause()->printPretty(OS, nullptr,
                   SemaRef.getPrintingPolicy());
           }));
     else {
       TPLInst.Clear();
+      TPL->setRequiresClause(SubstConstraint.get());
       Sema::InstantiatingTemplate TypeInst(SemaRef, SourceLocation(), Req, Info,
                                            SourceRange());
       if (TypeInst.isInvalid())
         return nullptr;
       TypeSourceInfo *TransType = TransformType(
           RetReq.getConstrainedParamExpectedType());
       if (!TransType)
         TransRetReq.emplace(createSubstDiag(SemaRef, Info,
return RebuildExprRequirement(E, Req->isSimple(), Req->getNoexceptLoc(),
                                   std::move(*TransRetReq));
   return RebuildExprRequirement(
       TransExpr.get<Requirement::SubstitutionDiagnostic *>(), Req->isSimple(),
       Req->getNoexceptLoc(), std::move(*TransRetReq));
 }
 
 NestedRequirement *
 TemplateInstantiator::TransformNestedRequirement(NestedRequirement *Req) {
-  if (!Req->isDependent() && !AlwaysRebuild())
-    return Req;
-  if (Req->isSubstitutionFailure()) {
-    if (AlwaysRebuild())
-      return RebuildNestedRequirement(
-          Req->getSubstitutionDiagnostic());
-    return Req;
-  }
-  Sema::InstantiatingTemplate ReqInst(SemaRef,
-      Req->getConstraintExpr()->getBeginLoc(), Req,
-      Sema::InstantiatingTemplate::ConstraintsCheck{},
-      Req->getConstraintExpr()->getSourceRange());
-
-  ExprResult TransConstraint;
-  TemplateDeductionInfo Info(Req->getConstraintExpr()->getBeginLoc());
-  {
-    EnterExpressionEvaluationContext ContextRAII(
-        SemaRef, Sema::ExpressionEvaluationContext::ConstantEvaluated);
-    Sema::SFINAETrap Trap(SemaRef);
-    Sema::InstantiatingTemplate ConstrInst(SemaRef,
-        Req->getConstraintExpr()->getBeginLoc(), Req, Info,
-        Req->getConstraintExpr()->getSourceRange());
-    if (ConstrInst.isInvalid())
-      return nullptr;
-    TransConstraint = TransformExpr(Req->getConstraintExpr());
-    if (TransConstraint.isInvalid() || Trap.hasErrorOccurred())
-      return RebuildNestedRequirement(createSubstDiag(SemaRef, Info,
-          [&] (llvm::raw_string_ostream& OS) {
-              Req->getConstraintExpr()->printPretty(OS, nullptr,
-                                                    SemaRef.getPrintingPolicy());
-          }));
-  }
-  return RebuildNestedRequirement(TransConstraint.get());
+  return RebuildNestedRequirement(Req->getConstraintExpr(), TemplateArgs);
 }
 
 
 /// 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.
if (auto *Function = dyn_cast<FunctionDecl>(D)) {
         //   An explicit instantiation definition that names a class template
         //   specialization explicitly instantiates the class template
         //   specialization and is only an explicit instantiation definition
         //   of members whose definition is visible at the point of
         //   instantiation.
         if (TSK == TSK_ExplicitInstantiationDefinition && !Pattern->isDefined())
           continue;
 
+        // C++2a [temp.explicit]p10:
+        //   [...] provided that the associated constraints, if any, of that
+        //   member are satisfied by the template arguments of the explicit
+        //   instantiation. [...]
+        ConstraintSatisfaction Satisfaction;
+        if (CheckFunctionConstraints(Function, Satisfaction) ||
+            !Satisfaction.IsSatisfied)
+          continue;
+
         Function->setTemplateSpecializationKind(TSK, PointOfInstantiation);
 
         if (Function->isDefined()) {
           // Let the ASTConsumer know that this function has been explicitly
           // instantiated now, and its linkage might have changed.
           Consumer.HandleTopLevelDecl(DeclGroupRef(Function));
         } else if (TSK == TSK_ExplicitInstantiationDefinition) {
           InstantiateFunctionDefinition(PointOfInstantiation, Function);

lib/Sema/SemaTemplateInstantiateDecl.cpp

Decl *TemplateDeclInstantiator::VisitFunctionDecl(FunctionDecl *D,
   NestedNameSpecifierLoc QualifierLoc = D->getQualifierLoc();
   if (QualifierLoc) {
     QualifierLoc = SemaRef.SubstNestedNameSpecifierLoc(QualifierLoc,
                                                        TemplateArgs);
     if (!QualifierLoc)
       return nullptr;
   }
 
-  Expr *TrailingRequiresClause = D->getTrailingRequiresClause();
-  if (TrailingRequiresClause) {
-    ExprResult SubstRC = SemaRef.SubstExpr(TrailingRequiresClause,
-                                           TemplateArgs);
-    if (!SubstRC.isUsable() || SubstRC.isInvalid())
-      return nullptr;
-    TrailingRequiresClause = SubstRC.get();
-    if (!SemaRef.CheckConstraintExpression(TrailingRequiresClause))
-      return nullptr;
-  }
-
   // If we're instantiating a local function declaration, put the result
   // in the enclosing namespace; otherwise we need to find the instantiated
   // context.
   DeclContext *DC;
   if (D->isLocalExternDecl()) {
     DC = Owner;
     SemaRef.adjustContextForLocalExternDecl(DC);
   } else if (isFriend && QualifierLoc) {
Decl *TemplateDeclInstantiator::VisitFunctionDecl(FunctionDecl *D,
   Function->setLexicalDeclContext(LexicalDC);
 
   // Attach the parameters
   for (unsigned P = 0; P < Params.size(); ++P)
     if (Params[P])
       Params[P]->setOwningFunction(Function);
   Function->setParams(Params);
 
-  if (TrailingRequiresClause)
+  if (Expr *TrailingRequiresClause = D->getTrailingRequiresClause())
     Function->setTrailingRequiresClause(TrailingRequiresClause);
 
   if (TemplateParams) {
     // Our resulting instantiation is actually a function template, since we
     // are substituting only the outer template parameters. For example, given
     //
     //   template<typename T>
     //   struct X {
TemplateDeclInstantiator::VisitCXXMethodDecl(CXXMethodDecl *D,
   if (QualifierLoc) {
     QualifierLoc = SemaRef.SubstNestedNameSpecifierLoc(QualifierLoc,
                                                  TemplateArgs);
     if (!QualifierLoc)
       return nullptr;
   }
 
   Expr *TrailingRequiresClause = D->getTrailingRequiresClause();
-  if (TrailingRequiresClause) {
-    ExprResult SubstRC = SemaRef.SubstExpr(TrailingRequiresClause,
-                                           TemplateArgs);
-    if (!SubstRC.isUsable() || SubstRC.isInvalid())
-      return nullptr;
-    TrailingRequiresClause = SubstRC.get();
-    if (!SemaRef.CheckConstraintExpression(TrailingRequiresClause))
-      return nullptr;
-  }
 
   DeclContext *DC = Owner;
   if (isFriend) {
     if (QualifierLoc) {
       CXXScopeSpec SS;
       SS.Adopt(QualifierLoc);
       DC = SemaRef.computeDeclContext(SS);
 
Decl *TemplateDeclInstantiator::VisitTemplateTypeParmDecl(
   // TODO: don't always clone when decls are refcounted.
   assert(D->getTypeForDecl()->isTemplateTypeParmType());
 
   TemplateTypeParmDecl *Inst = TemplateTypeParmDecl::Create(
       SemaRef.Context, Owner, D->getBeginLoc(), D->getLocation(),
       D->getDepth() - TemplateArgs.getNumSubstitutedLevels(), D->getIndex(),
       D->getIdentifier(), D->wasDeclaredWithTypename(), D->isParameterPack());
   Inst->setAccess(AS_public);
-  if (Expr *CE = D->getConstraintExpression()) {
-    ExprResult Result = SemaRef.SubstExpr(CE, TemplateArgs);
-    if (Result.isInvalid())
-      return nullptr;
-    Inst->setConstraintExpression(Result.get());
-  }
   if (D->hasDefaultArgument() && !D->defaultArgumentWasInherited()) {
     TypeSourceInfo *InstantiatedDefaultArg =
         SemaRef.SubstType(D->getDefaultArgumentInfo(), TemplateArgs,
                           D->getDefaultArgumentLoc(), D->getDeclName());
     if (InstantiatedDefaultArg)
       Inst->setDefaultArgument(InstantiatedDefaultArg);
   }
 
+  if (D->getConstraintExpression())
+    Inst->setInheritedConstraintExpression(D);
+
   // Introduce this template parameter's instantiation into the instantiation
   // scope.
   SemaRef.CurrentInstantiationScope->InstantiatedLocal(D, Inst);
 
   return Inst;
 }
 
 Decl *TemplateDeclInstantiator::VisitNonTypeTemplateParmDecl(
Param = NonTypeTemplateParmDecl::Create(
         SemaRef.Context, Owner, D->getInnerLocStart(), D->getLocation(),
         D->getDepth() - TemplateArgs.getNumSubstitutedLevels(),
         D->getPosition(), D->getIdentifier(), T, D->isParameterPack(), DI);
 
   Param->setAccess(AS_public);
   if (Invalid)
     Param->setInvalidDecl();
 
-  if (Expr *CE = D->getConstraintExpression()) {
-    ExprResult Result = SemaRef.SubstExpr(CE, TemplateArgs);
-    if (Result.isInvalid())
-      return nullptr;
-    Param->setConstraintExpression(Result.get());
-  }
   if (D->hasDefaultArgument() && !D->defaultArgumentWasInherited()) {
     EnterExpressionEvaluationContext ConstantEvaluated(
         SemaRef, Sema::ExpressionEvaluationContext::ConstantEvaluated);
     ExprResult Value = SemaRef.SubstExpr(D->getDefaultArgument(), TemplateArgs);
     if (!Value.isInvalid())
       Param->setDefaultArgument(Value.get());
   }
 
+  if (D->getConstraintExpression())
+    Param->setInheritedConstraintExpression(D);
+
   // Introduce this template parameter's instantiation into the instantiation
   // scope.
   SemaRef.CurrentInstantiationScope->InstantiatedLocal(D, Param);
   return Param;
 }
 
 static void collectUnexpandedParameterPacks(
     Sema &S,
Param = TemplateTemplateParmDecl::Create(
         SemaRef.Context, Owner, D->getLocation(),
         D->getDepth() - TemplateArgs.getNumSubstitutedLevels(),
         D->getPosition(), D->getIdentifier(), InstParams, ExpandedParams);
   else
     Param = TemplateTemplateParmDecl::Create(
         SemaRef.Context, Owner, D->getLocation(),
         D->getDepth() - TemplateArgs.getNumSubstitutedLevels(),
         D->getPosition(), D->isParameterPack(), D->getIdentifier(), InstParams);
-  if (Expr *CE = D->getConstraintExpression()) {
-    ExprResult Result = SemaRef.SubstExpr(CE, TemplateArgs);
-    if (Result.isInvalid())
-      return nullptr;
-    Param->setConstraintExpression(Result.get());
-  }
   if (D->hasDefaultArgument() && !D->defaultArgumentWasInherited()) {
     NestedNameSpecifierLoc QualifierLoc =
         D->getDefaultArgument().getTemplateQualifierLoc();
     QualifierLoc =
         SemaRef.SubstNestedNameSpecifierLoc(QualifierLoc, TemplateArgs);
     TemplateName TName = SemaRef.SubstTemplateName(
         QualifierLoc, D->getDefaultArgument().getArgument().getAsTemplate(),
         D->getDefaultArgument().getTemplateNameLoc(), TemplateArgs);
     if (!TName.isNull())
       Param->setDefaultArgument(
           SemaRef.Context,
           TemplateArgumentLoc(TemplateArgument(TName),
                               D->getDefaultArgument().getTemplateQualifierLoc(),
                               D->getDefaultArgument().getTemplateNameLoc()));
   }
+
+  if (D->getConstraintExpression())
+    Param->setInheritedConstraintExpression(D);
+
   Param->setAccess(AS_public);
 
   // Introduce this template parameter's instantiation into the instantiation
   // scope.
   SemaRef.CurrentInstantiationScope->InstantiatedLocal(D, Param);
 
   return Param;
 }
for (auto &P : *L) {
     Params.push_back(D);
     Invalid = Invalid || !D || D->isInvalidDecl();
   }
 
   // Clean up if we had an error.
   if (Invalid)
     return nullptr;
 
-  // FIXME: Concepts: Substitution into requires clause should only happen when
-  // checking satisfaction.
-  Expr *InstRequiresClause = nullptr;
-  if (Expr *E = L->getRequiresClause()) {
-    ExprResult Res = SemaRef.SubstExpr(E, TemplateArgs);
-    if (Res.isInvalid() || !Res.isUsable()) {
-      return nullptr;
-    }
-    InstRequiresClause = Res.get();
-  }
-
   TemplateParameterList *InstL
     = TemplateParameterList::Create(SemaRef.Context, L->getTemplateLoc(),
                                     L->getLAngleLoc(), Params,
-                                    L->getRAngleLoc(), InstRequiresClause);
+                                    L->getRAngleLoc(),
+                                    /*RequiresClause=*/nullptr,
+                                    /*InheritedConstraints=*/L);
   return InstL;
 }
 
 TemplateParameterList *
 Sema::SubstTemplateParams(TemplateParameterList *Params, DeclContext *Owner,
                           const MultiLevelTemplateArgumentList &TemplateArgs) {
   TemplateDeclInstantiator Instantiator(*this, Owner, TemplateArgs);
   return Instantiator.SubstTemplateParams(Params);
if (addInstantiatedParametersToScope(*this, Decl, Template, Scope,
     UpdateExceptionSpec(Decl, EST_None);
     return;
   }
 
   SubstExceptionSpec(Decl, Template->getType()->castAs<FunctionProtoType>(),
                      TemplateArgs);
 }
 
-bool Sema::CheckInstantiatedFunctionTemplateConstraints(
-    SourceLocation PointOfInstantiation, FunctionDecl *Decl,
-    ArrayRef<TemplateArgument> TemplateArgs,
+bool Sema::CheckFunctionConstraints(FunctionDecl *Decl,
     ConstraintSatisfaction &Satisfaction) {
+  NamedDecl *Template = Decl->getPrimaryTemplate();
+  llvm::SmallVector<const Expr *, 3> AssociatedConstraints;
+  if (Template) {
+    AssociatedConstraints =
+        cast<TemplateDecl>(Template)->getAssociatedConstraints();
+  } else {
+    AssociatedConstraints = Decl->getAssociatedConstraints();
+    if (!AssociatedConstraints.empty()) {
+      DeclContext *DC = Decl->getParent();
+      while (!DC->isFileContext()) {
+        if (auto *Spec = dyn_cast<ClassTemplateSpecializationDecl>(DC)) {
+          if (Spec->getSpecializationKind() == TSK_ExplicitSpecialization &&
+              !isa<ClassTemplatePartialSpecializationDecl>(Spec))
+            break;
+          if (!isa<ClassTemplatePartialSpecializationDecl>(Spec)) {
+            Template = Spec->getSpecializedTemplate();
+          } else {
+            Template = Spec;
+          }
+          break;
+        }
+        if (auto *Record = dyn_cast<CXXRecordDecl>(DC))
+          if (auto *ClassTemplate = Record->getDescribedClassTemplate()) {
+            Template = ClassTemplate;
+            break;
+          }
+        if (auto *Function = dyn_cast<FunctionDecl>(DC))
+          if (auto *FunctionTemplate = Function->getDescribedTemplate()) {
+            Template = FunctionTemplate;
+            break;
+          }
+        DC = DC->getParent();
+      }
+    }
+  }
+
+  if (AssociatedConstraints.empty()) {
+    Satisfaction.IsSatisfied = true;
+    return false;
+  }
+
+  if (!Template) {
+    // This is a non-template function which is also not a method of a template
+    // class.
+    if (Expr *RC = Decl->getTrailingRequiresClause())
+      return CheckConstraintSatisfaction(RC, Satisfaction);
+
+    Satisfaction.IsSatisfied = true;
+    return false;
+  }
+
+  // This is either an instantiated function template or a non-template method
+  // of a class template.
+
   // Enter the scope of this instantiation. We don't use
   // PushDeclContext because we don't have a scope.
   Sema::ContextRAII savedContext(*this, Decl);
   LocalInstantiationScope Scope(*this);
 
   MultiLevelTemplateArgumentList MLTAL =
-    getTemplateInstantiationArgs(Decl, nullptr, /*RelativeToPrimary*/true);
+      getTemplateInstantiationArgs(Decl, /*Innermost=*/nullptr,
+                                   /*RelativeToPrimary*/true);
 
   // If this is not an explicit specialization - we need to get the instantiated
   // version of the template arguments and add them to scope for the
   // substitution.
   if (Decl->isTemplateInstantiation())
     if (addInstantiatedParametersToScope(*this, Decl,
                                         Decl->getTemplateInstantiationPattern(),
                                          Scope, MLTAL))
       return true;
 
-  FunctionTemplateDecl *Template = Decl->getPrimaryTemplate();
+
   // Note - code synthesis context for the constraints check is created
   // inside CheckConstraintsSatisfaction.
-  return CheckConstraintSatisfaction(Template,
-                                     Template->getAssociatedConstraints(),
-                                     TemplateArgs,
-                                     PointOfInstantiation, Satisfaction);
+  if (auto *TD = dyn_cast<TemplateDecl>(Template))
+    return CheckConstraintSatisfaction(TD, AssociatedConstraints, MLTAL,
+                                       Decl->getPointOfInstantiation(),
+                                       Satisfaction);
+  if (auto *Var = dyn_cast<VarTemplatePartialSpecializationDecl>(Template))
+    return CheckConstraintSatisfaction(Var, AssociatedConstraints, MLTAL,
+                                       Decl->getPointOfInstantiation(),
+                                       Satisfaction);
+  return CheckConstraintSatisfaction(
+      cast<ClassTemplatePartialSpecializationDecl>(Template),
+      AssociatedConstraints, MLTAL, Decl->getPointOfInstantiation(),
+      Satisfaction);
 }
 
 /// Initializes the common fields of an instantiation function
 /// declaration (New) from the corresponding fields of its template (Tmpl).
 ///
 /// \returns true if there was an error
 bool
 TemplateDeclInstantiator::InitFunctionInstantiation(FunctionDecl *New,

lib/Sema/TreeTransform.h

   ExprRequirement *
   RebuildExprRequirement(Expr *E, bool IsSimple, SourceLocation NoexceptLoc,
                          ExprRequirement::ReturnTypeRequirement Ret) {
     return new (SemaRef.Context) ExprRequirement(SemaRef, E, IsSimple,
                                                  NoexceptLoc, std::move(Ret));
   }
 
   NestedRequirement *
-  RebuildNestedRequirement(Requirement::SubstitutionDiagnostic *SubstDiag) {
-    return new (SemaRef.Context) NestedRequirement(SubstDiag);
+  RebuildNestedRequirement(Expr *Constraint,
+                           const MultiLevelTemplateArgumentList &TemplateArgs) {
+    return new (SemaRef.Context) NestedRequirement(SemaRef, Constraint,
+                                                   TemplateArgs);
   }
 
-  NestedRequirement *RebuildNestedRequirement(Expr *Constraint) {
-    return new (SemaRef.Context) NestedRequirement(SemaRef, Constraint);
+  NestedRequirement *
+  RebuildNestedRequirement(Expr *Constraint) {
+    return new (SemaRef.Context) NestedRequirement(Constraint);
   }
 
   /// \brief 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 RebuildObjCBoxedExpr(SourceRange SR, Expr *ValueExpr) {
     return getSema().BuildObjCBoxedExpr(SR, ValueExpr);
TreeTransform<Derived>::TransformRequiresExpr(RequiresExpr *E) {
 
   return getDerived().RebuildRequiresExpr(E->getRequiresKWLoc(), Body,
                                           TransParams, TransReqs,
                                           E->getRBraceLoc());
 }
 
 template<typename Derived>
 bool TreeTransform<Derived>::TransformRequiresExprRequirements(
-    ArrayRef<Requirement *> Reqs,
-    SmallVectorImpl<Requirement *> &Transformed) {
+    ArrayRef<Requirement *> Reqs, SmallVectorImpl<Requirement *> &Transformed) {
   for (Requirement *Req : Reqs) {
     Requirement *TransReq = nullptr;
     if (auto *TypeReq = dyn_cast<TypeRequirement>(Req))
       TransReq = getDerived().TransformTypeRequirement(TypeReq);
     else if (auto *ExprReq = dyn_cast<ExprRequirement>(Req))
       TransReq = getDerived().TransformExprRequirement(ExprReq);
     else
       TransReq = getDerived().TransformNestedRequirement(
TreeTransform<Derived>::TransformExprRequirement(ExprRequirement *Req) {
   return getDerived().RebuildExprRequirement(
       TransExpr.get<Requirement::SubstitutionDiagnostic *>(), Req->isSimple(),
       Req->getNoexceptLoc(), std::move(*TransRetReq));
 }
 
 template<typename Derived>
 NestedRequirement *
 TreeTransform<Derived>::TransformNestedRequirement(NestedRequirement *Req) {
-  if (Req->isSubstitutionFailure()) {
-    if (getDerived().AlwaysRebuild())
-      return getDerived().RebuildNestedRequirement(
-          Req->getSubstitutionDiagnostic());
-    return Req;
-  }
   ExprResult TransConstraint =
       getDerived().TransformExpr(Req->getConstraintExpr());
   if (TransConstraint.isInvalid())
     return nullptr;
   return getDerived().RebuildNestedRequirement(TransConstraint.get());
 }
 
 template<typename Derived>

lib/Serialization/ASTReader.cpp

ASTReader::ReadTemplateParameterList(ModuleFile &F,
   SourceLocation RAngleLoc = ReadSourceLocation(F, Record, Idx);
 
   unsigned NumParams = Record[Idx++];
   SmallVector<NamedDecl *, 16> Params;
   Params.reserve(NumParams);
   while (NumParams--)
     Params.push_back(ReadDeclAs<NamedDecl>(F, Record, Idx));
 
+  // TODO: Concepts: We do not preserve constraint inheritance here.
   bool HasRequiresClause = Record[Idx++];
   Expr *RequiresClause = HasRequiresClause ? ReadExpr(F) : nullptr;
 
   TemplateParameterList *TemplateParams = TemplateParameterList::Create(
       getContext(), TemplateLoc, LAngleLoc, Params, RAngleLoc, RequiresClause);
   return TemplateParams;
 }
 

lib/Serialization/ASTReaderDecl.cpp

void ASTDeclReader::VisitVarTemplatePartialSpecializationDecl(
   }
 }
 
 void ASTDeclReader::VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D) {
   VisitTypeDecl(D);
 
   D->setDeclaredWithTypename(Record.readInt());
 
-  // TODO: Concepts: Constrained parameters
+  if (Record.readInt()) {
     if (Record.readInt())
       D->setConstraintExpression(Record.readExpr());
+    else
+      D->setInheritedConstraintExpression(
+          Record.readDeclAs<TemplateTypeParmDecl>());
+  }
 
   if (Record.readInt())
     D->setDefaultArgument(GetTypeSourceInfo());
 }
 
 void ASTDeclReader::VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D) {
   VisitDeclaratorDecl(D);
   // TemplateParmPosition.
   D->setDepth(Record.readInt());
   D->setPosition(Record.readInt());
   if (D->isExpandedParameterPack()) {
     auto TypesAndInfos =
         D->getTrailingObjects<std::pair<QualType, TypeSourceInfo *>>();
     for (unsigned I = 0, N = D->getNumExpansionTypes(); I != N; ++I) {
       new (&TypesAndInfos[I].first) QualType(Record.readType());
       TypesAndInfos[I].second = GetTypeSourceInfo();
     }
   } else {
     // Rest of NonTypeTemplateParmDecl.
     D->ParameterPack = Record.readInt();
-    // TODO: Concepts: Constrained parameters
+    if (Record.readInt()) {
       if (Record.readInt())
         D->setConstraintExpression(Record.readExpr());
+      else
+        D->setInheritedConstraintExpression(
+            Record.readDeclAs<NonTypeTemplateParmDecl>());
+    }
     if (Record.readInt())
       D->setDefaultArgument(Record.readExpr());
   }
 }
 
 void ASTDeclReader::VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D) {
   VisitTemplateDecl(D);
   // TemplateParmPosition.
   D->setDepth(Record.readInt());
   D->setPosition(Record.readInt());
   if (D->isExpandedParameterPack()) {
     auto **Data = D->getTrailingObjects<TemplateParameterList *>();
     for (unsigned I = 0, N = D->getNumExpansionTemplateParameters();
          I != N; ++I)
       Data[I] = Record.readTemplateParameterList();
   } else {
     // Rest of TemplateTemplateParmDecl.
-    // TODO: Concepts: Constrained parameters
     D->ParameterPack = Record.readInt();
+    if (Record.readInt()) {
       if (Record.readInt())
         D->setConstraintExpression(Record.readExpr());
+      else
+        D->setInheritedConstraintExpression(
+            Record.readDeclAs<TemplateTemplateParmDecl>());
+    }
     if (Record.readInt())
       D->setDefaultArgument(Reader.getContext(),
                             Record.readTemplateArgumentLoc());
   }
 }
 
 void ASTDeclReader::VisitTypeAliasTemplateDecl(TypeAliasTemplateDecl *D) {
   VisitRedeclarableTemplateDecl(D);

lib/Serialization/ASTReaderStmt.cpp

switch (RK) {
                     Status);
           else
             R = new (Record.getContext()) ExprRequirement(
                     E.get<Requirement::SubstitutionDiagnostic *>(),
                     RK == Requirement::RK_Simple, NoexceptLoc, std::move(*Req));
         }
       } break;
       case Requirement::RK_Nested: {
-        if (bool IsSubstitutionDiagnostic = Record.readInt()) {
-          SourceLocation SubstDiagLocation = Record.readSourceLocation();
-          std::string SubstDiagMessage = Record.readString();
-          R = new (Record.getContext()) NestedRequirement(
-              readSubstitutionDiagnostic(Record));
-          break;
-        }
         Expr *E = Record.readExpr();
-        if (E->isInstantiationDependent())
+        if (/*IsDependent=*/Record.readInt()) {
           R = new (Record.getContext()) NestedRequirement(E);
-        else
+        } else
           R = new (Record.getContext()) NestedRequirement(E,
                   readConstraintSatisfaction(Record));
       } break;
     }
     if (!R)
       continue;
     Requirements.push_back(R);
   }

lib/Serialization/ASTWriter.cpp

void ASTRecordWriter::AddTemplateParameterList(
   assert(TemplateParams && "No TemplateParams!");
   AddSourceLocation(TemplateParams->getTemplateLoc());
   AddSourceLocation(TemplateParams->getLAngleLoc());
   AddSourceLocation(TemplateParams->getRAngleLoc());
 
   Record->push_back(TemplateParams->size());
   for (const auto &P : *TemplateParams)
     AddDeclRef(P);
+  // TODO: Concepts: We do not preserve constraint inheritance here.
   if (const Expr *RequiresClause = TemplateParams->getRequiresClause()) {
     Record->push_back(true);
     AddStmt(const_cast<Expr*>(RequiresClause));
   } else {
     Record->push_back(false);
   }
 }
 

lib/Serialization/ASTWriterDecl.cpp

 
 void ASTDeclWriter::VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D) {
   VisitTypeDecl(D);
 
   Record.push_back(D->wasDeclaredWithTypename());
 
   Expr *CE = D->getConstraintExpression();
   Record.push_back(CE != nullptr);
-  if (CE)
+  if (CE) {
+    bool OwnsCE = !D->constraintExpressionWasInherited();
+    Record.push_back(OwnsCE);
+    if (OwnsCE)
       Record.AddStmt(CE);
+    else
+      Record.AddDeclRef(D->getInheritedFromConstraintExpressionDecl());
+  }
 
   bool OwnsDefaultArg = D->hasDefaultArgument() &&
                         !D->defaultArgumentWasInherited();
   Record.push_back(OwnsDefaultArg);
   if (OwnsDefaultArg)
     Record.AddTypeSourceInfo(D->getDefaultArgumentInfo());
 
   Code = serialization::DECL_TEMPLATE_TYPE_PARM;
void ASTDeclWriter::VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D) {
   if (D->isExpandedParameterPack()) {
     for (unsigned I = 0, N = D->getNumExpansionTypes(); I != N; ++I) {
       Record.AddTypeRef(D->getExpansionType(I));
       Record.AddTypeSourceInfo(D->getExpansionTypeSourceInfo(I));
     }
 
     Code = serialization::DECL_EXPANDED_NON_TYPE_TEMPLATE_PARM_PACK;
   } else {
-    // TODO: Concepts - constrained parameters.
     // Rest of NonTypeTemplateParmDecl.
     Record.push_back(D->isParameterPack());
     Expr *CE = D->getConstraintExpression();
     Record.push_back(CE != nullptr);
-    if (CE)
+    if (CE) {
+      bool OwnsCE = !D->constraintExpressionWasInherited();
+      Record.push_back(OwnsCE);
+      if (OwnsCE)
         Record.AddStmt(CE);
+      else
+        Record.AddDeclRef(D->getInheritedFromConstraintExpressionDecl());
+    }
     bool OwnsDefaultArg = D->hasDefaultArgument() &&
                           !D->defaultArgumentWasInherited();
     Record.push_back(OwnsDefaultArg);
     if (OwnsDefaultArg)
       Record.AddStmt(D->getDefaultArgument());
     Code = serialization::DECL_NON_TYPE_TEMPLATE_PARM;
   }
 }
void ASTDeclWriter::VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D) {
   Record.push_back(D->getPosition());
 
   if (D->isExpandedParameterPack()) {
     for (unsigned I = 0, N = D->getNumExpansionTemplateParameters();
          I != N; ++I)
       Record.AddTemplateParameterList(D->getExpansionTemplateParameters(I));
     Code = serialization::DECL_EXPANDED_TEMPLATE_TEMPLATE_PARM_PACK;
   } else {
-    // TODO: Concepts - constrained parameters.
     // Rest of TemplateTemplateParmDecl.
     Record.push_back(D->isParameterPack());
     Expr *CE = D->getConstraintExpression();
     Record.push_back(CE != nullptr);
-    if (CE)
+    if (CE) {
+      bool OwnsCE = !D->constraintExpressionWasInherited();
+      Record.push_back(OwnsCE);
+      if (OwnsCE)
         Record.AddStmt(CE);
+      else
+        Record.AddDeclRef(D->getInheritedFromConstraintExpressionDecl());
+    }
     bool OwnsDefaultArg = D->hasDefaultArgument() &&
                           !D->defaultArgumentWasInherited();
     Record.push_back(OwnsDefaultArg);
     if (OwnsDefaultArg)
       Record.AddTemplateArgumentLoc(D->getDefaultArgument());
     Code = serialization::DECL_TEMPLATE_TEMPLATE_PARM;
   }
 }

lib/Serialization/ASTWriterStmt.cpp

if (auto *TypeReq = dyn_cast<TypeRequirement>(R)) {
           assert(RetReq.isEmpty());
           Record.push_back(0);
         }
       }
     } else {
       auto *NestedReq = cast<NestedRequirement>(R);
       Record.push_back(Requirement::RK_Nested);
 
-      if (auto *SubstDiag =
-            NestedReq->Value.dyn_cast<Requirement::SubstitutionDiagnostic *>()){
-        addSubstitutionDiagnostic(Record, SubstDiag);
-      } else {
-        Record.AddStmt(NestedReq->Value.get<Expr *>());
-        if (!NestedReq->isDependent())
-          addConstraintSatisfaction(Record, NestedReq->Satisfaction);
-      }
-    }
-  }
+      Record.AddStmt(NestedReq->getConstraintExpr());
+      Record.push_back(NestedReq->isDependent());
   Record.AddSourceLocation(E->getEndLoc());
 
   Code = serialization::EXPR_REQUIRES;
 }
 
 
 void ASTStmtWriter::VisitCapturedStmt(CapturedStmt *S) {
   VisitStmt(S);

test/CXX/concepts-ts/expr/expr.prim/expr.prim.id/p4.cpp

 }
 
 namespace methods
 {
   template<typename T>
   struct A {
     static void foo(int) requires (sizeof(T) == 1) {} // expected-note 3{{because 'sizeof(char [2]) == 1' (2 == 1) evaluated to false}}
     static void bar(int) requires (sizeof(T) == 2) {} // expected-note 3{{because 'sizeof(char) == 2' (1 == 2) evaluated to false}}
+    template<typename U>
+    static void baz(int) requires (sizeof(T) == 2) {
+      struct { static void goo() requires (sizeof(T) > sizeof(U)) {} } a;
+      // expected-note@-1{{because 'sizeof(short) > sizeof(int)' (2 > 4) evaluated to false}}
+      a.goo();
+      // expected-error@-1{{invalid reference to function 'goo': constraints not satisfied}}
+    }
   };
 
   void baz() {
     A<char>::foo(1);
     A<char>::bar(1); // expected-error{{invalid reference to function 'bar': constraints not satisfied}}
+    A<short>::baz<int>(1); // expected-note{{in instantiation of function template specialization 'methods::A<short>::baz<int>' requested here}}
     A<char[2]>::foo(1); // expected-error{{invalid reference to function 'foo': constraints not satisfied}}
     A<char[2]>::bar(1);
     void (*p1)(int) = A<char>::foo;
     void (*p2)(int) = A<char>::bar; // expected-error{{invalid reference to function 'bar': constraints not satisfied}}
     void (*p3)(int) = A<char[2]>::foo; // expected-error{{invalid reference to function 'foo': constraints not satisfied}}
     void (*p4)(int) = A<char[2]>::bar;
     decltype(A<char>::foo)* a1 = nullptr;
     decltype(A<char>::bar)* a2 = nullptr; // expected-error{{invalid reference to function 'bar': constraints not satisfied}}
struct A {
     A<T> operator-(A<T> b) requires (sizeof(T) == 1) { return b; } // expected-note{{because 'sizeof(int) == 1' (4 == 1) evaluated to false}}
   };
 
   void baz() {
     auto* x = &A<int>::operator-; // expected-error{{invalid reference to function 'operator-': constraints not satisfied}}
     auto y = &A<char>::operator-;
   }
 }
 No newline at end of file

test/CXX/concepts-ts/expr/expr.prim/expr.prim.req/equivalence.cpp

 // RUN: %clang_cc1 -std=c++2a -fconcepts-ts -x c++ %s -verify
 
 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> struct identity { using type = T; };
 template<typename T> using identity_t = T;
 
 // Type requirements
-template<typename T> requires requires { typename identity_t<T>; }
+template<typename T> requires requires { typename identity_t<T>; } // expected-note{{template is declared here}}
 struct r1;
-template<typename U> requires requires { typename identity_t<U>; } // expected-note{{previous template declaration is here}}
+template<typename U> requires requires { typename identity_t<U>; }
 struct r1;
 template<typename T> requires requires { typename identity_t<T*>; } // expected-error{{associated constraints differ in template redeclaration}}
 struct r1;
 template<typename T> requires requires { typename ::identity_t<T>; }
 struct r1;
 
-template<typename Y> requires requires { typename identity<Y>::type; }
+template<typename Y> requires requires { typename identity<Y>::type; } // expected-note 2{{template is declared here}}
 struct r2;
 template<typename U> requires requires { typename identity<U>::type; }
 struct r2;
-template<typename T> requires requires { typename ::identity<T>::type; } // expected-note 2{{previous template declaration is here}}
+template<typename T> requires requires { typename ::identity<T>::type; }
 struct r2;
 template<typename T> requires requires { typename identity<T>::typr; } // expected-error{{associated constraints differ in template redeclaration}}
 struct r2;
 namespace ns {
   template<typename T> struct identity { using type = T; };
 }
 template<typename T> requires requires { typename ns::identity<T>::type; } // expected-error{{associated constraints differ in template redeclaration}}
 struct r2;
 
-template<typename T> requires requires { typename T::template identity<T>::type; }
+template<typename T> requires requires { typename T::template identity<T>::type; } // expected-note{{template is declared here}}
 struct r3;
-template<typename U> requires requires { typename U::template identity<U>::type; } // expected-note{{previous template declaration is here}}
+template<typename U> requires requires { typename U::template identity<U>::type; }
 struct r3;
 template<typename T> requires requires { typename T::template identitr<T>::type; } // expected-error{{associated constraints differ in template redeclaration}}
 struct r3;
 
 template<typename T> requires requires { typename T::template temp<>; }
 struct r4;
 template<typename U> requires requires { typename U::template temp<>; }
 struct r4;
 
 // Expr requirements
-template<typename T> requires requires { 0; } // expected-note{{previous template declaration is here}}
+template<typename T> requires requires { 0; } // expected-note{{template is declared here}}
 struct r5;
 template<typename T> requires requires { 1; } // expected-error{{associated constraints differ in template redeclaration}}
 struct r5;
 
 template<typename T>
 concept C1 = true;
 
-template<typename T> requires requires { sizeof(T); }
+template<typename T> requires requires { sizeof(T); } // expected-note 4{{template is declared here}}
 struct r6;
-template<typename U> requires requires { sizeof(U); } // expected-note{{previous template declaration is here}}
+template<typename U> requires requires { sizeof(U); }
 struct r6;
 template<typename U> requires requires { sizeof(U) - 1; } // expected-error{{associated constraints differ in template redeclaration}}
 struct r6;
-template<typename T> requires requires { { sizeof(T) }; } // expected-note 3{{previous template declaration is here}}
+template<typename T> requires requires { { sizeof(T) }; }
 struct r6;
 template<typename T> requires requires { { sizeof(T) } -> decltype(sizeof(int)); } // expected-error{{associated constraints differ in template redeclaration}}
 struct r6;
 template<typename T> requires requires { { sizeof(T) } noexcept; } // expected-error{{associated constraints differ in template redeclaration}}
 struct r6;
 template<typename T> requires requires { { sizeof(T) } -> C1; } // expected-error{{associated constraints differ in template redeclaration}}
 struct r6;
 
-template<typename T> requires requires { { sizeof(T) } -> int; }
+template<typename T> requires requires { { sizeof(T) } -> int; } // expected-note 3{{template is declared here}}
 struct r7;
-template<typename U> requires requires { { sizeof(U) } -> int; } // expected-note 3{{previous template declaration is here}}
+template<typename U> requires requires { { sizeof(U) } -> int; }
 struct r7;
 template<typename T> requires requires { { sizeof(T) } -> const int; } // expected-error{{associated constraints differ in template redeclaration}}
 struct r7;
 template<typename T> requires requires { { sizeof(T) } noexcept -> int; } // expected-error{{associated constraints differ in template redeclaration}}
 struct r7;
 template<typename T> requires requires { { sizeof(T) } -> T; } // expected-error{{associated constraints differ in template redeclaration}}
 struct r7;
 
-template<typename T> requires requires { { sizeof(T) } -> C1; }
+template<typename T> requires requires { { sizeof(T) } -> C1; } // expected-note 2{{template is declared here}}
 struct r8;
 template<typename U> requires requires { { sizeof(U) } -> C1; }
 struct r8;
-template<typename T> requires requires { { sizeof(T) } -> C1<>; } // expected-note 2{{previous template declaration is here}}
+template<typename T> requires requires { { sizeof(T) } -> C1<>; }
 struct r8;
 template<typename U> requires requires { { sizeof(U) }; } // expected-error{{associated constraints differ in template redeclaration}}
 struct r8;
 template<typename T> requires requires { { sizeof(T) } -> const C1; } // expected-error{{associated constraints differ in template redeclaration}}
 struct r8;
 
 template<typename T> requires requires { { sizeof(T) } -> const volatile C1; }
 struct r9;
 template<typename U> requires requires { { sizeof(U) } -> const volatile C1; }
 struct r9;
 template<typename T> requires requires { { sizeof(T) } -> C1 const volatile; }
 struct r9;
 template<typename T> requires requires { { sizeof(T) } -> C1 volatile const; }
 struct r9;
 template<typename T> requires requires { { sizeof(T) } -> const C1 volatile; }
 struct r9;
 template<typename T> requires requires { { sizeof(T) } -> volatile C1 const; }
 struct r9;
 
-template<typename T> requires requires { { sizeof(T) } -> C1[sizeof(T)]; }
+template<typename T> requires requires { { sizeof(T) } -> C1[sizeof(T)]; } // expected-note 2{{template is declared here}}
 struct r10;
-template<typename U> requires requires { { sizeof(U) } -> C1[sizeof(U)]; } // expected-note 2{{previous template declaration is here}}
+template<typename U> requires requires { { sizeof(U) } -> C1[sizeof(U)]; }
 struct r10;
 template<typename T> requires requires { { sizeof(T) } -> C1[sizeof(T) - 1]; } // expected-error{{associated constraints differ in template redeclaration}}
 struct r10;
 template<typename T> requires requires { { sizeof(T) } -> C1; } // expected-error{{associated constraints differ in template redeclaration}}
 struct r10;
 
 template<typename T, typename U>
 concept C2 = true;
 
-template<typename T> requires requires { { sizeof(T) } -> C2<T>; }
+template<typename T> requires requires { { sizeof(T) } -> C2<T>; } // expected-note{{template is declared here}}
 struct r11;
-template<typename U> requires requires { { sizeof(U) } -> C2<U>; } // expected-note{{previous template declaration is here}}
+template<typename U> requires requires { { sizeof(U) } -> C2<U>; }
 struct r11;
 template<typename T> requires requires { { sizeof(T) } -> C2<T*>; } // expected-error{{associated constraints differ in template redeclaration}}
 struct r11;
 
 // Nested requirements
-template<typename T> requires requires { requires sizeof(T) == 0; }
+template<typename T> requires requires { requires sizeof(T) == 0; } // expected-note{{template is declared here}}
 struct r12;
-template<typename U> requires requires { requires sizeof(U) == 0; } // expected-note{{previous template declaration is here}}
+template<typename U> requires requires { requires sizeof(U) == 0; }
 struct r12;
 template<typename T> requires requires { requires sizeof(T) == 1; } // expected-error{{associated constraints differ in template redeclaration}}
 struct r12;
 
 // Parameter list
-template<typename T> requires requires { requires true; }
+template<typename T> requires requires { requires true; } // expected-note{{template is declared here}}
 struct r13;
-template<typename T> requires requires() { requires true; } // expected-note{{previous template declaration is here}}
+template<typename T> requires requires() { requires true; }
 struct r13;
 template<typename T> requires requires(T i) { requires true; } // expected-error{{associated constraints differ in template redeclaration}}
 struct r13;
 
-template<typename T> requires requires(T i, T *j) { requires true; } // expected-note 2{{previous template declaration is here}}
+template<typename T> requires requires(T i, T *j) { requires true; } // expected-note 2{{template is declared here}}
 struct r14;
 template<typename T> requires requires(T i) { requires true; } // expected-error{{associated constraints differ in template redeclaration}}
 struct r14;
 template<typename T> requires requires(T i, T *j, T &k) { requires true; } // expected-error{{associated constraints differ in template redeclaration}}
 struct r14;
 
 // Parameter names
-template<typename T> requires requires(int i) { requires sizeof(i) == 1; }
+template<typename T> requires requires(int i) { requires sizeof(i) == 1; } // expected-note 2{{template is declared here}}
 struct r15;
-template<typename T> requires requires(int j) { requires sizeof(j) == 1; } // expected-note 2{{previous template declaration is here}}
+template<typename T> requires requires(int j) { requires sizeof(j) == 1; }
 struct r15;
 template<typename T> requires requires(int k) { requires sizeof(k) == 2; } // expected-error{{associated constraints differ in template redeclaration}}
 struct r15;
 template<typename T> requires requires(const int k) { requires sizeof(k) == 1; } // expected-error{{associated constraints differ in template redeclaration}}
 struct r15;
 
 // Order of requirements
-template<typename T> requires requires { requires true; 0; }
+template<typename T> requires requires { requires true; 0; } // expected-note{{template is declared here}}
 struct r16;
-template<typename T> requires requires { requires true; 0; } // expected-note{{previous template declaration is here}}
+template<typename T> requires requires { requires true; 0; }
 struct r16;
 template<typename T> requires requires { 0; requires true; } // expected-error{{associated constraints differ in template redeclaration}}
 struct r16;

test/CXX/concepts-ts/expr/expr.prim/expr.prim.req/nested-requirement.cpp

 
 template<typename T> requires requires (T t) { requires sizeof(t) == 0; } // expected-note{{because 'sizeof (t) == 0' (4 == 0) evaluated to false}}
 struct r3 {};
 
 using r3i = r3<int>; // expected-error{{constraints not satisfied for class template 'r3' [with T = int]}}
 
 template<typename T>
 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'}}
+    template<typename U> requires requires (U u) { requires decltype(u)::hey == sizeof(T); }
+    // expected-note@-1{{because substituted constraint expression is ill-formed: type 'decltype(u)' (aka 'int') cannot be used prior to '::' because it has no members}}
     struct r4 {};
 };
 
-using r4i = X<void>::r4<int>; // expected-error{{constraints not satisfied for class template 'r4' [with U = int]}}
+using r4i = X<int>::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 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'}}
   using dc1 = D_check<short>; // expected-error{{constraints not satisfied for class template 'D_check' [with T = short]}}
 
   template<typename T>
   concept C2 = requires (T a) { // expected-note{{'a' declared here}}
       requires sizeof(a) == 4; // OK
       requires a == 0; // expected-error{{constraint variable 'a' cannot be used in an evaluated context}}
     };
-}
+}
 

test/CXX/concepts-ts/over/over.match/over.match.best/p1.cpp

namespace templates
   template<typename T>
   void bar() requires (sizeof(T) == 1) { }
   // expected-note@-1{{and here}}
   // expected-note@-2{{candidate function [with T = char]}}
 
   template<typename T>
   void bar() requires (sizeof(T) == 1 && sizeof(T) >= 0) { }
   // expected-note@-1{{candidate function [with T = char]}}
-  // expected-note@-2{{'sizeof(char) == 1' in the two declarations is not considered equivalent - move it to a concept and reference it from here:}}
+  // expected-note@-2{{'sizeof(T) == 1' in the two declarations is not considered equivalent - move it to a concept and reference it from here:}}
 
   static_assert(is_same_v<decltype(bar<char>()), void>);
   // expected-error@-1{{call to 'bar' is ambiguous}}
 
   template<typename T>
   constexpr int baz() requires AtLeast1<T> { // expected-note {{candidate function}}
     return 1;
   }
namespace non_template
 
   constexpr int doo(int b) requires AtLeast2<int> { // expected-note {{candidate function}}
     return 2;
   }
 
   static_assert(goo(1) == 1);
   static_assert(doo(2) == 1); // expected-error {{call to 'doo' is ambiguous}}
 }
-

test/CXX/concepts-ts/temp/temp.arg.template/p3.cpp

 // RUN:  %clang_cc1 -std=c++2a -fconcepts-ts -verify %s
 
 template<typename T> concept C = T::f();
 // expected-note@-1{{and here}}
 template<typename T> concept D = C<T> && T::g();
 template<typename T> concept F = T::f();
 // expected-note@-1{{'T::f()' in the two declarations is not considered equivalent - move it to a concept and reference it from here:}}
+template<typename T, typename U> concept G = T::f();
+
 template<template<C> class P> struct S1 { }; // expected-note 2{{'P' declared here}}
 
 template<C> struct X { }; // expected-note{{'X' declared here}}
 
 template<D> struct Y { }; // expected-note 2{{'Y' declared here}}
 template<typename T> struct Z { };
 template<F> struct W { }; // expected-note{{'W' declared here}}
+template<G<int>> struct U { }; // expected-note{{'U' declared here}}
+template<G<int(int)>> struct V { }; // expected-note 2{{'V' declared here}}
 
 S1<X> s11;
 S1<Y> s12; // expected-error{{template template argument 'Y' must not be more constrained than template template parameter 'P'}}
 S1<Z> s13;
 S1<W> s14; // expected-error{{template template argument 'W' must not be more constrained than template template parameter 'P'}}
 
 template<template<typename> class P> struct S2 { }; // expected-note 2{{'P' declared here}}
 
 S2<X> s21; // expected-error{{template template argument 'X' must not be more constrained than template template parameter 'P'}}
 S2<Y> s22; // expected-error{{template template argument 'Y' must not be more constrained than template template parameter 'P'}}
 S2<Z> s23;
+
+template<typename T, template<G<T>> class P> struct S3 { };
+// expected-note@-1{{'P' declared here}}
+
+S3<int, U> s31;
+S3<void, U> s32; // expected-error{{template template argument 'U' must not be more constrained than template template parameter 'P'}}
+
+template<typename T>
+struct S4 {
+  template<typename U, template<G<U(T)>> class P> struct S { };
+  // expected-note@-1 2{{'P' declared here}}
+};
+
+S4<int>::S<int, V> s41;
+S4<int>::S<double, V> s42; // expected-error{{template template argument 'V' must not be more constrained than template template parameter 'P'}}
+S4<double>::S<int, V> s43; // expected-error{{template template argument 'V' must not be more constrained than template template parameter 'P'}}
 No newline at end of file

test/CXX/concepts-ts/temp/temp.constr/temp.constr.constr/non-function-templates.cpp

template<typename T> requires B<T>::type // expected-note{{in instantiation of template class 'B<int>' requested here}}
                                          // expected-note@-1{{while substituting template arguments into constraint expression here}}
 struct C { };
 
 template<typename T> requires (T{}) // expected-error{{atomic constraint must be of type 'bool' (found 'int')}}
 struct D { };
 
 static_assert(C<int>{}); // expected-note{{while checking constraint satisfaction for template 'C<int>' required here}}
 static_assert(D<int>{}); // expected-note{{while checking constraint satisfaction for template 'D<int>' required here}}
+
+template<typename T>
+struct dummy {
+    template<typename U>
+        requires (sizeof(U) == 4)
+    class A;
+    using type = A<int>;
+};

test/CXX/concepts-ts/temp/temp.constr/temp.constr.decl/class-template-decl.cpp

 struct B;
 template <C1 U> requires (bool(U()))
 struct B;
 
 } // end namespace nodiag
 
 namespace diag {
 
-template <typename T> requires true // expected-note{{previous template declaration is here}}
+template <typename T> requires true // expected-note{{template is declared here}}
 struct A;
 template <typename T> struct A; // expected-error{{associated constraints differ in template redeclaration}}
 
-template <typename T> struct B; // expected-note{{previous template declaration is here}}
+template <typename T> struct B; // expected-note{{template is declared here}}
 template <typename T> requires true // expected-error{{associated constraints differ in template redeclaration}}
 struct B;
 
-template <typename T> requires true // expected-note{{previous template declaration is here}}
+template <typename T> requires true // expected-note{{template is declared here}}
 struct C;
 template <typename T> requires (!0) // expected-error{{associated constraints differ in template redeclaration}}
 struct C;
 
 template<typename T>
 concept C1 = true;
 
-template <C1 T> // expected-note{{previous template declaration is here}}
+template <C1 T> // expected-note{{template is declared here}}
 struct D;
 template <typename T> requires C1<T> // expected-error{{associated constraints differ in template redeclaration}}
 struct D;
 
 } // end namespace diag
 
 namespace nodiag {
 

 };
 
 } // end namespace nodiag
 
 namespace diag {
 
 template <unsigned N>
 struct TA {
-  template <template <unsigned> class TT> requires TT<N>::happy // expected-note {{previous template declaration is here}}
+  template <template <unsigned> class TT> requires TT<N>::happy // expected-note {{template is declared here}}
   struct A;
 
-  template <template <unsigned> class TT> requires TT<N>::happy // expected-note {{previous template declaration is here}}
+  template <template <unsigned> class TT> requires TT<N>::happy // expected-note {{template is declared here}}
   struct B;
 
   struct AF;
 };
 
 template <unsigned N>
 template <template <unsigned> class TT> struct TA<N>::A { }; // expected-error{{associated constraints differ in template redeclaration}}
 

test/CXX/concepts-ts/temp/temp.constr/temp.constr.decl/p3.cpp

 // RUN: %clang_cc1 -std=c++2a -fconcepts-ts -x c++ -verify %s
 
 template<typename T>
 struct X {
     using Y = typename T::invalid;
 };
 
 template<typename T>
 concept Invalid = X<T>{};
 
 template<typename T>
-concept False = false; // expected-note{{because 'false' evaluated to false}}
+concept False = false; // expected-note 2{{because 'false' evaluated to false}}
 
 template<typename T>
 concept True = true;
 
-// TODO: Concepts: Uncomment trailing requires clauses here when we have correct substitution.
-//template<True T>
-//  requires False<T>
-//void g1() requires Invalid<T>;
-//
-//using g1i = decltype(g1<int>());
+template<True T>
+  requires False<T> // expected-note{{because 'int' does not satisfy 'False'}}
+void g1() requires Invalid<T>;
+// expected-note@-1{{candidate template ignored: constraints not satisfied [with T = int]}}
+
+using g1i = decltype(g1<int>());
+// expected-error@-1{{no matching function for call to 'g1'}}
 
 template<False T> // expected-note{{because 'int' does not satisfy 'False'}}
   requires Invalid<T>
 void g2(); // requires Invalid<T>;
 // expected-note@-1{{candidate template ignored: constraints not satisfied [with T = int]}}
 
 using g2i = decltype(g2<int>());
 // expected-error@-1{{no matching function for call to 'g2'}}
 No newline at end of file

test/CXX/concepts-ts/temp/temp.constr/temp.constr.decl/var-template-decl.cpp

 template <typename U> requires (bool(U()))
 int B::A = int(U());
 
 } // end namespace nodiag
 
 namespace diag {
 
 struct B {
-    template <typename T> requires (bool(T())) // expected-note{{previous template declaration is here}}
+    template <typename T> requires (bool(T())) // expected-note{{template is declared here}}
     static int A;
 };
 
 template <typename U> requires (!bool(U()))  // expected-error{{associated constraints differ in template redeclaration}}
 int B::A = int(U());
 
 } // end namespace diag
 No newline at end of file

test/CXX/concepts-ts/temp/temp.constr/temp.constr.normal/p1.cpp

namespace ill_formed_subst {
   struct B; // expected-note 2{{template is declared here}}
 
   template<typename T>
   concept C1 = true;
 
   template<typename T, typename U>
   concept C2 = C1<typename B<U>::foo>;
   // expected-error@-1 2{{implicit instantiation of undefined template 'ill_formed_subst::B<int>'}}
-  // expected-note@-2 2{{when substituting into C1<typename B<U>::foo> [with T = type-parameter-0-0, U = int]. Make sure concept arguments are valid for any substitution}}
+  // expected-note@-2 2{{when substituting into C1<typename B<U>::foo>. Make sure concept arguments are valid for any substitution}}
 
   template<typename T> requires C2<T, int>
   struct A {}; // expected-note {{template is declared here}}
 
   template<typename T> requires C2<T, int> && true
   struct A<T> {}; // expected-error {{class template partial specialization is not more specialized than the primary template}}
 }
 
 namespace incorrect_args_after_subst {
   template<typename T>
   concept C1 = true; // expected-note 2{{template is declared here}}
 
   template<typename... Ts>
   concept C2 = C1<Ts...>;
   // expected-error@-1 2{{too many template arguments for concept 'C1'}}
-  // expected-note@-2 2{{when substituting into C1<Ts...> [with Ts = <type-parameter-0-0, type-parameter-0-0>]. Make sure concept arguments are valid for any substitution}}
+  // expected-note@-2 2{{when substituting into C1<Ts...>. Make sure concept arguments are valid for any substitution}}
 
   template<typename T> requires C2<T, T>
   struct A {}; // expected-note{{template is declared here}}
 
   template<typename T> requires C2<T, T> && true
   struct A<T> {}; // expected-error{{class template partial specialization is not more specialized than the primary template}}
 }
 

test/CXX/concepts-ts/temp/temp.constr/temp.constr.order/class-template-partial-specializations.cpp

 class C<T>{};
 
 template<typename T>
 class D{}; // expected-note{{previous definition is here}}
 
 template<typename T>
 class D<T>{}; // expected-error{{class template partial specialization does not specialize any template argument; to define the primary template, remove the template argument list}} expected-error{{redefinition of 'D'}}
 
-template<typename T> requires C1<T> // expected-note{{previous template declaration is here}}
+template<typename T> requires C1<T> // expected-note{{template is declared here}}
 class E{};
 
 template<typename T> // expected-error{{associated constraints differ in template redeclaration}}
 class E<T>{}; // expected-error{{class template partial specialization does not specialize any template argument; to define the primary template, remove the template argument list}}
 
 template<typename T>
 struct F{ enum{ value = 1 }; };
 

 
 // Make sure atomic constraints subsume each other only if their parameter
 // mappings are identical.
 
 template<typename T, typename U> requires C2<T>
 struct I { }; // expected-note {{template is declared here}}
 
 template<typename T, typename U> requires C2<U>
-struct I<T, U> { }; // expected-error {{class template partial specialization is not more specialized than the primary template}}
+struct I<T, U> { }; // expected-error {{class template partial specialization is not more specialized than the primary template}}
 

test/CXX/concepts-ts/temp/temp.explicit/p10.cpp

+// RUN: %clang_cc1 -std=c++2a -fconcepts-ts -x c++ -verify %s
+// expected-no-diagnostics
+
+template <typename T>
+concept Comparable = requires(T a) { {a == a} -> bool; };
+
+template <typename T>
+struct W {
+  T val;
+
+  bool operator==(W const& y) const
+    requires Comparable<T>
+  { return this->val == y.val; }
+};
+
+struct X {};
+static_assert(!Comparable<X>);
+static_assert(!Comparable<W<X>>);
+template struct W<X>;
 No newline at end of file

test/CXX/concepts-ts/temp/temp.inst/p17.cpp

+// RUN:  %clang_cc1 -std=c++2a -fconcepts-ts -verify %s
+// expected-no-diagnostics
+
+template<typename T>
+struct dont_instantiate { using T::value; };
+
+template<typename T>
+struct S1 {
+    template<typename U> requires dont_instantiate<T>::value
+    struct S2 { };
+
+    void f() requires dont_instantiate<T>::value;
+};
+
+S1<int> s;
 No newline at end of file

test/SemaTemplate/instantiate-requires-expr.cpp

 
 using r1i1 = r1<int>; // expected-error {{constraints not satisfied for class template 'r1' [with T = int]}}
 using r1i2 = r1<char>; // expected-error {{constraints not satisfied for class template 'r1' [with T = char]}}
 
 // Check that parameter packs work.
 
 template<typename... Ts> requires
 false_v<requires (Ts... ts) {requires ((sizeof(ts) == 2) && ...);}>
-// expected-note@-1 {{because 'false_v<requires (short ts, unsigned short ts) { requires (sizeof (ts) == 2) && (sizeof (ts) == 2); }>'}}
-// expected-note@-2 {{because 'false_v<requires (short ts) { requires (sizeof (ts) == 2); }>' evaluated to false}}
+// expected-note@-1 {{because 'false_v<requires (short ts, unsigned short ts) { requires ((sizeof (ts) == 2) && ...); }>'}}
+// expected-note@-2 {{because 'false_v<requires (short ts) { requires ((sizeof (ts) == 2) && ...); }>' evaluated to false}}
 struct r2 {};
 
 using r2i1 = r2<short, unsigned short>; // expected-error {{constraints not satisfied for class template 'r2' [with Ts = <short, unsigned short>]}}
 using r2i2 = r2<short>; // expected-error {{constraints not satisfied for class template 'r2' [with Ts = <short>]}}
 
 template<typename... Ts> requires
 false_v<(requires (Ts ts) {requires sizeof(ts) != 0;} && ...)>
 // expected-note@-1 {{because 'false_v<requires (short ts) { requires sizeof (ts) != 0; } && requires (unsigned short ts) { requires sizeof (ts) != 0; }>' evaluated to false}}
namespace expr_requirement {
   // expected-note@-1 {{because 'false_v<requires { { sizeof(int) } noexcept -> const volatile int; } && requires { { sizeof(unsigned int) } noexcept -> const volatile unsigned int; }>' evaluated to false}}
   struct r11 {};
 
   using r11i = r11<int, unsigned int>; // expected-error{{constraints not satisfied for class template 'r11' [with Ts = <int, unsigned int>]}}
 }
 
 namespace nested_requirement {
   // check that constraint expression is instantiated correctly
-  template<typename T> requires false_v<requires { requires sizeof(T) == 2; }> // expected-note{{because 'false_v<requires { requires sizeof(int) == 2; }>' evaluated to false}}
+  // (substitution doesn't actually occur at the expression level because of [expr.prim.req.nested]p1
+  template<typename T> requires false_v<requires { requires sizeof(T) == 2; }> // expected-note{{because 'false_v<requires { requires sizeof(T) == 2; }>' evaluated to false}}
   struct r1 {};
 
   using r1i = r1<int>; // expected-error{{constraints not satisfied for class template 'r1' [with T = int]}}
 
-  // substitution error occurs in expr, then expr is instantiated again.
+  // substitution occurs in expr, then expr is instantiated again.
   template<typename T>
   struct a {
+      template<typename U, decltype(requires { requires sizeof(T) + sizeof(U) != 0; }) W>
+      struct r {};
+  };
+
+  using ari = a<int>::r<int, true>;
+
+  // substitution error occurs in expr, then expr is instantiated again.
+  template<typename T>
+  struct b {
       template<typename U> requires
-      (requires { requires sizeof(T::a) == 0; }, false) // expected-note{{because 'requires { requires <<error-expression>>; } , false' evaluated to false}}
+      (requires { requires sizeof(T::a) == 0; }, false) // expected-note{{because 'requires { requires sizeof (T::a) == 0; } , false' evaluated to false}}
       struct r {};
   };
 
-  using ari = a<int>::r<short>; // expected-error{{constraints not satisfied for class template 'r' [with U = short]}}
+  using bri = b<int>::r<short>; // expected-error{{constraints not satisfied for class template 'r' [with U = short]}}
 
   // Parameter pack inside expr
   template<typename... Ts> requires
   false_v<(requires { requires sizeof(Ts) == 0; } && ...)>
-  // expected-note@-1 {{because 'false_v<requires { requires sizeof(int) == 0; } && requires { requires sizeof(short) == 0; }>' evaluated to false}}
+  // expected-note@-1 {{because 'false_v<requires { requires sizeof(Ts) == 0; } && requires { requires sizeof(Ts) == 0; }>' evaluated to false}}
   struct r2 {};
 
   using r2i = r2<int, short>; // expected-error{{constraints not satisfied for class template 'r2' [with Ts = <int, short>]}}
 }
 
 // Parameter pack inside multiple requirements
 template<typename... Ts> requires
 false_v<(requires { requires sizeof(Ts) == 0; sizeof(Ts); } && ...)>
-// expected-note@-1 {{because 'false_v<requires { requires sizeof(int) == 0; sizeof(Ts); } && requires { requires sizeof(short) == 0; sizeof(Ts); }>' evaluated to false}}
+// expected-note@-1 {{because 'false_v<requires { requires sizeof(Ts) == 0; sizeof(Ts); } && requires { requires sizeof(Ts) == 0; sizeof(Ts); }>' evaluated to false}}
 struct r4 {};
 
 using r4i = r4<int, short>; // expected-error{{constraints not satisfied for class template 'r4' [with Ts = <int, short>]}}
 
 template<typename... Ts> requires
 false_v<(requires(Ts t) { requires sizeof(t) == 0; t++; } && ...)>
 // expected-note@-1 {{because 'false_v<requires (int t) { requires sizeof (t) == 0; t++; } && requires (short t) { requires sizeof (t) == 0; t++; }>' evaluated to false}}
 struct r5 {};