[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

70–71

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

96–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.

1276

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").
   void getAssociatedConstraints(llvm::SmallVectorImpl<const Expr *> &AC) 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;
 
class TemplateTypeParmDecl final : public TypeDecl,
   friend TrailingObjects;
 
   /// Whether this template type parameter was declaration with
   /// the 'typename' keyword.
   ///
   /// If false, it was declared with the 'class' keyword.
   bool Typename : 1;
 
-  /// Whether this template type parameter has a type-constraint construct.
-  bool HasTypeConstraint : 1;
+  /// Whether this template type parameter owns a type-constraint construct.
+  bool OwnsTypeConstraint : 1;
 
-  /// Whether the type constraint has been initialized. This can be false if the
-  /// constraint was not initialized yet or if there was an error forming the
-  /// type constriant.
-  bool TypeConstraintInitialized : 1;
+  /// The int indicates whether the type constraint was initialized, and if the
+  /// pointer is not null, it means that the type constraint was inherited from
+  /// another declaration, and points to that declaration.
+  enum TypeConstraintStatus {
+      TCS_None,
+      TCS_Uninitialized,
+      TCS_Owned,
+      TCS_Inherited
+  };
+  llvm::PointerIntPair<TemplateTypeParmDecl *, 2, TypeConstraintStatus>
+      TypeConstraintStatus;
 
   /// The default template argument, if any.
   using DefArgStorage =
       DefaultArgStorage<TemplateTypeParmDecl, TypeSourceInfo *>;
   DefArgStorage DefaultArgument;
 
   TemplateTypeParmDecl(DeclContext *DC, SourceLocation KeyLoc,
                        SourceLocation IdLoc, IdentifierInfo *Id,
-                       bool Typename, bool HasTypeConstraint)
+                       bool Typename, bool OwnsTypeConstraint)
       : TypeDecl(TemplateTypeParm, DC, IdLoc, Id, KeyLoc), Typename(Typename),
-      HasTypeConstraint(HasTypeConstraint), TypeConstraintInitialized(false) {}
+      OwnsTypeConstraint(OwnsTypeConstraint),
+      TypeConstraintStatus(nullptr,
+                           OwnsTypeConstraint ? TCS_Uninitialized : TCS_None) {}
 
 public:
   static TemplateTypeParmDecl *Create(const ASTContext &C, DeclContext *DC,
                                       SourceLocation KeyLoc,
                                       SourceLocation NameLoc,
                                       unsigned D, unsigned P,
                                       IdentifierInfo *Id, bool Typename,
                                       bool ParameterPack,
-                                      bool HasTypeConstraint);
+                                      bool OwnsTypeConstraint);
   static TemplateTypeParmDecl *CreateDeserialized(const ASTContext &C,
                                                   unsigned ID);
   static TemplateTypeParmDecl *CreateDeserialized(const ASTContext &C,
                                                   unsigned ID,
-                                                  bool HasTypeConstraint);
+                                                  bool OwnsTypeConstraint);
 
   /// Whether this template type parameter was declared with
   /// the 'typename' keyword.
   ///
   /// If not, it was either declared with the 'class' keyword or with a
   /// type-constraint (see hasTypeConstraint()).
   bool wasDeclaredWithTypename() const {
-    return Typename && !HasTypeConstraint;
+    return Typename && !hasTypeConstraint();
   }
 
   const DefArgStorage &getDefaultArgStorage() const { return DefaultArgument; }
 
   /// Determine whether this template parameter has a default
   /// argument.
   bool hasDefaultArgument() const { return DefaultArgument.isSet(); }
 
public:
   unsigned getIndex() const;
 
   /// Returns whether this is a parameter pack.
   bool isParameterPack() const;
 
   /// Returns the type constraint associated with this template parameter (if
   /// any).
   const TypeConstraint *getTypeConstraint() const {
-    return TypeConstraintInitialized ? getTrailingObjects<TypeConstraint>() :
-         nullptr;
+    switch (TypeConstraintStatus.getInt()) {
+    case TCS_None:
+      return nullptr;
+    case TCS_Inherited:
+      return getInheritedFromTypeConstraintDecl()->getTypeConstraint();
+    case TCS_Owned:
+      return getTrailingObjects<TypeConstraint>();
+    case TCS_Uninitialized:
+      llvm_unreachable("Type constraint should be initialized before we can "
+                       "access it");
+    }
+    llvm_unreachable("Unhandled case");
   }
 
   void setTypeConstraint(NestedNameSpecifierLoc NNS,
                          DeclarationNameInfo NameInfo, NamedDecl *FoundDecl,
                          ConceptDecl *CD,
                          const ASTTemplateArgumentListInfo *ArgsAsWritten,
                          Expr *ImmediatelyDeclaredConstraint);
 
   /// Determine whether this template parameter has a type-constraint.
   bool hasTypeConstraint() const {
-    return HasTypeConstraint;
+    return TypeConstraintStatus.getInt() != TCS_None;
+  }
+
+  /// \brief Sets the type constraint associated with this template
+  /// parameter (if any) to inherit the type constraint of a previously declared
+  /// template parameter.
+  void setInheritedTypeConstraint(TemplateTypeParmDecl *Prev) {
+    assert(Prev->hasTypeConstraint());
+    TypeConstraintStatus.setPointer(Prev);
+    TypeConstraintStatus.setInt(TCS_Inherited);
+  }
+
+  TemplateTypeParmDecl *getInheritedFromTypeConstraintDecl() const {
+    assert(typeConstraintWasInherited());
+    return TypeConstraintStatus.getPointer();
+  }
+
+  bool typeConstraintWasInherited() const {
+    assert(hasTypeConstraint());
+    return TypeConstraintStatus.getInt() == TCS_Inherited;
   }
 
   /// \brief Get the associated-constraints of this template parameter.
   /// This will either be the immediately-introduced constraint or empty.
   ///
   /// Use this instead of getConstraintExpression for concepts APIs that
   /// accept an ArrayRef of constraint expressions.
   void getAssociatedConstraints(llvm::SmallVectorImpl<const Expr *> &AC) const {
-    if (HasTypeConstraint)
+    if (hasTypeConstraint())
       AC.push_back(getTypeConstraint()->getImmediatelyDeclaredConstraint());
   }
 
   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; }
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(TraverseStmt(ExprReq->getExpr()));
       auto &RetReq = ExprReq->getReturnTypeRequirement();
       if (RetReq.isTrailingReturnType())
         TRY_TO(TraverseTypeLoc(RetReq.getTrailingReturnTypeExpectedType()
                                    ->getTypeLoc()));
       else if (RetReq.isTypeConstraint())
         TRY_TO(TraverseTemplateParameterListHelper(
                    RetReq.getTypeConstraintTemplateParameterList()));
-    } 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/DeclTemplate.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()) {

 // TemplateTypeParm Allocation/Deallocation Method Implementations
 //===----------------------------------------------------------------------===//
 
 TemplateTypeParmDecl *
 TemplateTypeParmDecl::Create(const ASTContext &C, DeclContext *DC,
                              SourceLocation KeyLoc, SourceLocation NameLoc,
                              unsigned D, unsigned P, IdentifierInfo *Id,
                              bool Typename, bool ParameterPack,
-                             bool HasTypeConstraint) {
+                             bool OwnsTypeConstraint) {
   auto *TTPDecl =
       new (C, DC,
-           additionalSizeToAlloc<TypeConstraint>(HasTypeConstraint ? 1 : 0))
+           additionalSizeToAlloc<TypeConstraint>(OwnsTypeConstraint ? 1 : 0))
       TemplateTypeParmDecl(DC, KeyLoc, NameLoc, Id, Typename,
-                           HasTypeConstraint);
+                           OwnsTypeConstraint);
   QualType TTPType = C.getTemplateTypeParmType(D, P, ParameterPack, TTPDecl);
   TTPDecl->setTypeForDecl(TTPType.getTypePtr());
   return TTPDecl;
 }
 
 TemplateTypeParmDecl *
 TemplateTypeParmDecl::CreateDeserialized(const ASTContext &C, unsigned ID) {
   return new (C, ID) TemplateTypeParmDecl(nullptr, SourceLocation(),
                                           SourceLocation(), nullptr, false,
                                           false);
 }
 
 TemplateTypeParmDecl *
 TemplateTypeParmDecl::CreateDeserialized(const ASTContext &C, unsigned ID,
-                                         bool HasTypeConstraint) {
+                                         bool OwnsTypeConstraint) {
   return new (C, ID,
-              additionalSizeToAlloc<TypeConstraint>(HasTypeConstraint ? 1 : 0))
+              additionalSizeToAlloc<TypeConstraint>(OwnsTypeConstraint ? 1 : 0))
          TemplateTypeParmDecl(nullptr, SourceLocation(), SourceLocation(),
                               nullptr, false, false);
 }
 
 SourceLocation TemplateTypeParmDecl::getDefaultArgumentLoc() const {
   return hasDefaultArgument()
              ? getDefaultArgumentInfo()->getTypeLoc().getBeginLoc()
              : SourceLocation();

 bool TemplateTypeParmDecl::isParameterPack() const {
   return getTypeForDecl()->getAs<TemplateTypeParmType>()->isParameterPack();
 }
 
 void TemplateTypeParmDecl::setTypeConstraint(NestedNameSpecifierLoc NNS,
     DeclarationNameInfo NameInfo, NamedDecl *FoundDecl, ConceptDecl *CD,
     const ASTTemplateArgumentListInfo *ArgsAsWritten,
     Expr *ImmediatelyDeclaredConstraint) {
-  assert(HasTypeConstraint &&
-         "HasTypeConstraint=true must be passed at construction in order to "
+  assert(OwnsTypeConstraint &&
+         "OwnsTypeConstraint=true must be passed at construction in order to "
          "call setTypeConstraint");
-  assert(!TypeConstraintInitialized &&
+  assert(TypeConstraintStatus.getInt() == TCS_Uninitialized &&
          "TypeConstraint was already initialized!");
   new (getTrailingObjects<TypeConstraint>()) TypeConstraint(NNS, NameInfo,
       FoundDecl, CD, ArgsAsWritten, ImmediatelyDeclaredConstraint);
-  TypeConstraintInitialized = true;
+  TypeConstraintStatus.setInt(TCS_Owned);
 }
 
 //===----------------------------------------------------------------------===//
 // NonTypeTemplateParmDecl Method Implementations
 //===----------------------------------------------------------------------===//
 
 NonTypeTemplateParmDecl::NonTypeTemplateParmDecl(
     DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, unsigned D,

 }
 
 static TemplateParameterList *
 createMakeIntegerSeqParameterList(const ASTContext &C, DeclContext *DC) {
   // typename T
   auto *T = TemplateTypeParmDecl::Create(
       C, DC, SourceLocation(), SourceLocation(), /*Depth=*/1, /*Position=*/0,
       /*Id=*/nullptr, /*Typename=*/true, /*ParameterPack=*/false,
-      /*HasTypeConstraint=*/false);
+      /*OwnsTypeConstraint=*/false);
   T->setImplicit(true);
 
   // T ...Ints
   TypeSourceInfo *TI =
       C.getTrivialTypeSourceInfo(QualType(T->getTypeForDecl(), 0));
   auto *N = NonTypeTemplateParmDecl::Create(
       C, DC, SourceLocation(), SourceLocation(), /*Depth=*/0, /*Position=*/1,
       /*Id=*/nullptr, TI->getType(), /*ParameterPack=*/true, TI);
auto *TemplateTemplateParm = TemplateTemplateParmDecl::Create(
       C, DC, SourceLocation(), /*Depth=*/0, /*Position=*/0,
       /*ParameterPack=*/false, /*Id=*/nullptr, TPL);
   TemplateTemplateParm->setImplicit(true);
 
   // typename T
   auto *TemplateTypeParm = TemplateTypeParmDecl::Create(
       C, DC, SourceLocation(), SourceLocation(), /*Depth=*/0, /*Position=*/1,
       /*Id=*/nullptr, /*Typename=*/true, /*ParameterPack=*/false,
-      /*HasTypeConstraint=*/false);
+      /*OwnsTypeConstraint=*/false);
   TemplateTypeParm->setImplicit(true);
 
   // T N
   TypeSourceInfo *TInfo = C.getTrivialTypeSourceInfo(
       QualType(TemplateTypeParm->getTypeForDecl(), 0));
   auto *NonTypeTemplateParm = NonTypeTemplateParmDecl::Create(
       C, DC, SourceLocation(), SourceLocation(), /*Depth=*/0, /*Position=*/2,
       /*Id=*/nullptr, TInfo->getType(), /*ParameterPack=*/false, TInfo);
createTypePackElementParameterList(const ASTContext &C, DeclContext *DC) {
   auto *Index = NonTypeTemplateParmDecl::Create(
       C, DC, SourceLocation(), SourceLocation(), /*Depth=*/0, /*Position=*/0,
       /*Id=*/nullptr, TInfo->getType(), /*ParameterPack=*/false, TInfo);
 
   // typename ...T
   auto *Ts = TemplateTypeParmDecl::Create(
       C, DC, SourceLocation(), SourceLocation(), /*Depth=*/0, /*Position=*/1,
       /*Id=*/nullptr, /*Typename=*/true, /*ParameterPack=*/true,
-      /*HasTypeConstraint=*/false);
+      /*OwnsTypeConstraint=*/false);
   Ts->setImplicit(true);
 
   // template <std::size_t Index, typename ...T>
   NamedDecl *Params[] = {Index, Ts};
   return TemplateParameterList::Create(C, SourceLocation(), SourceLocation(),
                                        llvm::makeArrayRef(Params),
                                        SourceLocation(), nullptr);
 }
void TypeConstraint::print(llvm::raw_ostream &OS, PrintingPolicy Policy) const {
   ConceptName.printName(OS);
   if (wereArgumentsSpecified()) {
     OS << "<";
     for (auto &ArgLoc : ArgsAsWritten->arguments())
       ArgLoc.getArgument().print(Policy, OS);
     OS << ">";
   }
 }
 No newline at end of file

lib/AST/StmtPrinter.cpp

if (auto *TypeReq = dyn_cast<TypeRequirement>(Req)) {
                                                                         Policy);
           else if (RetReq.isTypeConstraint())
             RetReq.getTypeConstraint()->print(OS, Policy);
         }
       }
     } 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)) {
         Visit(RetReq.getTypeConstraint()->getImmediatelyDeclaredConstraint());
       } 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
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() || Trap.hasErrorOccurred()) {
             // C++2a [temp.constr.atomic]p1
             //   ...If substitution results in an invalid type or expression, the
             //   constraint is not satisfied.
             if (!Trap.hasErrorOccurred())
               // A non-SFINAE error has occured as a result of this
               // substitution.
               return ExprError();
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;
   llvm::SmallVector<const Expr *, 3> AssociatedConstraints;
   TD->getAssociatedConstraints(AssociatedConstraints);
-  if (CheckConstraintSatisfaction(TD, AssociatedConstraints, TemplateArgs,
-                                  TemplateIDRange, Satisfaction))
+  TemplateArgumentList TAL(TemplateArgumentList::OnStack, TemplateArgs);
+  MultiLevelTemplateArgumentList MLTAL =
+      getTemplateInstantiationArgs(TD, /*Innermost=*/&TAL);
+  if (CheckConstraintSatisfaction(TD, AssociatedConstraints,
+                                  MLTAL, TemplateIDRange, Satisfaction))
     return true;
 
   if (!Satisfaction.IsSatisfied) {
     SmallString<128> TemplateArgString;
     TemplateArgString = " ";
     TemplateArgString += getTemplateArgumentBindingsText(
         TD->getTemplateParameters(), TemplateArgs.data(), TemplateArgs.size());
 
Sema::DiagnoseUnsatisfiedConstraint(const ConstraintSatisfaction& Satisfaction,
   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 TemplateParameterFinder : RecursiveASTVisitor<TemplateParameterFinder> {
+    llvm::SmallSet<TemplateTypeParmDecl *, 3> OccurringParameters;
+
+    bool VisitTemplateTypeParmType(TemplateTypeParmType *T) {
+      OccurringParameters.insert(T->getDecl());
+      return true;
+    }
+};
+
 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} {
+    // C++2a [temp.constr.atomic]p1
+    //   An atomic constraint is formed from an expression E and a mapping from
+    //   the template parameters that appear within E to template arguments
+    //   involving the template parameters of the constrained entity, called
+    //   the parameter mapping.
+    TemplateParameterFinder Finder;
+    Finder.TraverseStmt(const_cast<Expr *>(ConstraintExpr));
+    for (TemplateTypeParmDecl *Param : Finder.OccurringParameters)
+      if (ParameterMapping.empty())
+        // This signals the identity mapping
+        this->ParameterMapping.push_back(QualType(Param->getTypeForDecl(), 0));
+      else
+        this->ParameterMapping.push_back(ParameterMapping[Param->getIndex()]);
+  }
 
   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) {
     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)) {
       // C++ [temp.constr.normal]p1.1
       // [...]
       // The normal form of an id-expression of the form C<A1, A2, ..., AN>,
       // where C names a concept, is the normal form of the
       // constraint-expression of C, after substituting A1, A2, ..., AN for C’s
       // respective template parameters in the parameter mappings in each atomic
       // constraint. If any such substitution results in an invalid type or
       // expression, the program is ill-formed; no diagnostic is required.
       // [...]
       const ASTTemplateArgumentListInfo *Mapping =
           CSE->getTemplateArgsAsWritten();
-      if (!ParameterMapping) {
+      if (ParameterMapping.getNumLevels() == 0) {
         // This is a top level CSE.
         //
         // template<typename T>
         // concept C = true;
         //
         // template<typename U>
         // void foo() requires C<U> {} -> Mapping is <U>
         //
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.getNumLevels() != 0 ?
+            ParameterMapping.getInnermost() : ArrayRef<TemplateArgument>{})};
   }
 
   static llvm::Optional<NormalizedConstraint> fromConstraintExprs(Sema &S,
-      ArrayRef<const Expr *> E) {
+      ArrayRef<const Expr *> E,
+      const MultiLevelTemplateArgumentList &ParameterMapping) {
     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,
   // The cv part is done in the calling function - we get the concept with
   // arguments and the abstract declarator with the correct CV qualification and
   // have to synthesize T and the single parameter of F.
   auto &II = Context.Idents.get("expr-type");
   auto *TParam = TemplateTypeParmDecl::Create(Context, CurContext,
                                               SourceLocation(),
                                               SourceLocation(), Depth,
                                               /*Index=*/0, &II,
-                                              /*Typename=*/true,
+                                              /*Typename=*/false,
                                               /*ParameterPack=*/false,
-                                              /*HasTypeConstraint=*/true);
+                                              /*OwnsTypeConstraint=*/true);
 
   if (ActOnTypeConstraint(TypeConstraint, TParam,
                           /*EllpsisLoc=*/SourceLocation()))
     // Just produce a requirement with no type requirements.
     return new (Context) ExprRequirement(*this, E, /*IsSimple=*/false,
       NoexceptLoc, ExprRequirement::ReturnTypeRequirement());
 
   auto *TPL = TemplateParameterList::Create(Context, SourceLocation(),
                                             SourceLocation(),
                                             ArrayRef<NamedDecl *>(TParam),
                                             SourceLocation(),
                                             /*RequiresClause=*/nullptr);
 
   return new (Context) ExprRequirement(*this, E, /*IsSimple=*/false,
       NoexceptLoc, ExprRequirement::ReturnTypeRequirement(Context, TPL));
 }
 
 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,

lib/Sema/SemaTemplate.cpp

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() :
                                                        ConceptNameInfo.getLoc(),
                                                 TemplateArgs->getRAngleLoc()),
                                     Satisfaction))
       return ExprError();
+  }
 
   return ConceptSpecializationExpr::Create(Context,
       SS.isSet() ? SS.getWithLocInContext(Context) : NestedNameSpecifierLoc{},
       TemplateKWLoc, ConceptNameInfo, FoundDecl, NamedConcept,
       ASTTemplateArgumentListInfo::Create(Context, *TemplateArgs), 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].
       SmallVector<const Expr *, 3> ParamsAC, TemplateAC;
       Params->getAssociatedConstraints(ParamsAC);
       Template->getAssociatedConstraints(TemplateAC);
-      if (!IsAtLeastAsConstrained(Param, ParamsAC, Template, TemplateAC,
-                                  /*NoCache=*/true)) {
+      if (!IsAtLeastAsConstrained(ParamsAC, ParamMLTAL, TemplateAC, 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, ParamsAC, Template,
-                                                      TemplateAC);
+        MaybeEmitAmbiguousAtomicConstraintsDiagnostic(Param, ParamsAC,
+                                                      ParamMLTAL, Template, 
+                                                      TemplateAC, ArgMLTAL);
         return true;
       }
       return false;
     }
     // FIXME: Produce better diagnostics for deduction failures.
   }
 
   return !TemplateParameterListsAreEqual(Template->getTemplateParameters(),

lib/Sema/SemaTemplateDeduction.cpp

 
 template<typename TemplateDeclT>
 static Sema::TemplateDeductionResult
 CheckDeducedArgumentConstraints(Sema& S, TemplateDeclT *Template,
                                 ArrayRef<TemplateArgument> DeducedArgs,
                                 TemplateDeductionInfo& Info) {
   llvm::SmallVector<const Expr *, 3> AssociatedConstraints;
   Template->getAssociatedConstraints(AssociatedConstraints);
+  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, AssociatedConstraints,
-                                    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,
 
   // Build template<class TemplParam> void Func(FuncParam);
   TemplateTypeParmDecl *TemplParam = TemplateTypeParmDecl::Create(
       Context, nullptr, SourceLocation(), Loc, Depth, 0, nullptr, false, false,
       false);
   QualType TemplArg = QualType(TemplParam->getTypeForDecl(), 0);
   NamedDecl *TemplParamPtr = TemplParam;
   FixedSizeTemplateParameterListStorage<1, false> TemplateParamsSt(
-      Context, Loc, Loc, TemplParamPtr, Loc, nullptr);
+      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)
bool TransformRequiresExprRequirements(ArrayRef<Requirement *> Reqs,
             SatisfcationDetermined = true;
         } else
           TransReq = Req;
         Transformed.push_back(TransReq);
       }
       return false;
     }
 
+    ExprResult TransformConstraintExpr(Expr *Constraint) {
+      // C++2a [temp.inst]p17
+      //   The type-constraints and requires-clause of a template specialization
+      //   or member function are not instantiated along with the specialization
+      //   or function itself [...]
+      return Constraint;
+    }
+
     TemplateParameterList *TransformTemplateParameterList(
                               TemplateParameterList *OrigTPL)  {
       if (!OrigTPL || !OrigTPL->size()) return OrigTPL;
 
       DeclContext *Owner = OrigTPL->getParam(0)->getDeclContext();
       TemplateDeclInstantiator  DeclInstantiator(getSema(),
                         /* DeclContext *Owner */ Owner, TemplateArgs);
       return DeclInstantiator.SubstTemplateParams(OrigTPL);
if (!TransType)
       TransRetReq.emplace(createSubstDiag(SemaRef, Info,
           [&] (llvm::raw_string_ostream& OS) {
               RetReq.getTrailingReturnTypeExpectedType()->getType().print(OS,
                   SemaRef.getPrintingPolicy());
           }));
     else
       TransRetReq.emplace(SemaRef.Context, TransType);
   } else if (RetReq.isTypeConstraint()) {
-    TemplateParameterList *OrigTPL =
-        RetReq.getTypeConstraintTemplateParameterList();
-    Sema::InstantiatingTemplate TPLInst(SemaRef, OrigTPL->getTemplateLoc(),
-                                        Req, Info, OrigTPL->getSourceRange());
-    if (TPLInst.isInvalid())
-      return nullptr;
-    TemplateParameterList *TPL =
-        TransformTemplateParameterList(OrigTPL);
-    if (!TPL)
+    auto *OrigTParam =
+        cast<TemplateTypeParmDecl>(
+            RetReq.getTypeConstraintTemplateParameterList()->getParam(0));
+    auto *TParam =
+        TemplateTypeParmDecl::Create(
+            SemaRef.Context, OrigTParam->getDeclContext(), SourceLocation(),
+            SourceLocation(),
+            OrigTParam->getDepth() - TemplateArgs.getNumSubstitutedLevels(),
+            /*Index=*/0, OrigTParam->getIdentifier(), /*Typename=*/false,
+            /*ParameterPack=*/false, /*OwnsTypeConstraint=*/true);
+
+    auto *TC = RetReq.getTypeConstraint();
+    auto *OrigArgs = TC->getTemplateArgsAsWritten();
+    if (OrigArgs) {
+      Sema::InstantiatingTemplate TALInst(
+          SemaRef, OrigArgs->getLAngleLoc(), Req, Info,
+          SourceRange(OrigArgs->getLAngleLoc(), OrigArgs->getRAngleLoc()));
+      if (TALInst.isInvalid())
+        return nullptr;
+      TemplateArgumentListInfo InstTemplateArgs(OrigArgs->LAngleLoc,
+                                                OrigArgs->RAngleLoc);
+      if (TransformTemplateArguments(OrigArgs->getTemplateArgs(),
+                                     OrigArgs->NumTemplateArgs,
+                                     InstTemplateArgs))
         TransRetReq.emplace(createSubstDiag(SemaRef, Info,
             [&] (llvm::raw_string_ostream& OS) {
-              RetReq.getTypeConstraint()->getImmediatelyDeclaredConstraint()
-                  ->printPretty(OS, nullptr, SemaRef.getPrintingPolicy());
+                TC->print(OS, SemaRef.getPrintingPolicy());
             }));
       else {
-      TPLInst.Clear();
+        TALInst.Clear();
+
+        if (SemaRef.AttachTypeConstraint(TC->getNestedNameSpecifierLoc(),
+                                         TC->getConceptNameInfo(),
+                                         TC->getNamedConcept(),
+                                         &InstTemplateArgs, TParam,
+                                         /*EllipsisLoc=*/SourceLocation()))
+           return nullptr;
+      }
+    } else if (SemaRef.AttachTypeConstraint(TC->getNestedNameSpecifierLoc(),
+                                            TC->getConceptNameInfo(),
+                                            TC->getNamedConcept(),
+                                            /*TemplateArgs=*/nullptr, TParam,
+                                            /*EllipsisLoc=*/SourceLocation()))
+       return nullptr;
+
+    if (!TransRetReq) {
+      auto *TPL = TemplateParameterList::Create(SemaRef.Context,
+                                                SourceLocation(),
+                                                SourceLocation(),
+                                                ArrayRef<NamedDecl *>(TParam),
+                                                SourceLocation(),
+                                                /*RequiresClause=*/nullptr);
       TransRetReq.emplace(SemaRef.Context, TPL);
     }
   }
   assert(TransRetReq.hasValue() &&
          "All code paths leading here must set TransRetReq");
   if (Expr *E = TransExpr.dyn_cast<Expr *>())
     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(
                                                     TemplateTypeParmDecl *D) {
   // 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(),
-      D->hasTypeConstraint());
+      /*OwnsTypeConstraint=*/false);
   Inst->setAccess(AS_public);
-  if (auto *TC = D->getTypeConstraint()) {
-    // TODO: Concepts: do not instantiate the constraint (delayed constraint
-    // substitution)
-    const ASTTemplateArgumentListInfo *TemplArgInfo
-      = TC->getTemplateArgsAsWritten();
-    TemplateArgumentListInfo InstArgs;
-
-    if (TemplArgInfo) {
-      InstArgs.setLAngleLoc(TemplArgInfo->LAngleLoc);
-      InstArgs.setRAngleLoc(TemplArgInfo->RAngleLoc);
-      if (SemaRef.Subst(TemplArgInfo->getTemplateArgs(),
-                        TemplArgInfo->NumTemplateArgs,
-                        InstArgs, TemplateArgs))
-        return nullptr;
-    }
-    ExprResult Result =
-        SemaRef.SubstExpr(TC->getImmediatelyDeclaredConstraint(), TemplateArgs);
-    if (Result.isInvalid())
-      return nullptr;
-
-    Inst->setTypeConstraint(TC->getNestedNameSpecifierLoc(),
-        TC->getConceptNameInfo(), TC->getFoundDecl(), TC->getNamedConcept(),
-        TemplArgInfo ? ASTTemplateArgumentListInfo::Create(SemaRef.Context,
-                                                           InstArgs) : nullptr,
-        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->hasTypeConstraint()) {
+    if (D->typeConstraintWasInherited())
+      Inst->setInheritedTypeConstraint(D->getInheritedFromTypeConstraintDecl());
+    else
+      Inst->setInheritedTypeConstraint(D);
+  }
+
   // Introduce this template parameter's instantiation into the instantiation
   // scope.
   SemaRef.CurrentInstantiationScope->InstantiatedLocal(D, Inst);
 
   return Inst;
 }
 
 Decl *TemplateDeclInstantiator::VisitNonTypeTemplateParmDecl(
TemplateName TName = SemaRef.SubstTemplateName(
         D->getDefaultArgument().getTemplateNameLoc(), TemplateArgs);
     if (!TName.isNull())
       Param->setDefaultArgument(
           SemaRef.Context,
           TemplateArgumentLoc(TemplateArgument(TName),
                               D->getDefaultArgument().getTemplateQualifierLoc(),
                               D->getDefaultArgument().getTemplateNameLoc()));
   }
+
   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) {
+    cast<TemplateDecl>(Template)->getAssociatedConstraints(AssociatedConstraints);
+  } else {
+    Decl->getAssociatedConstraints(AssociatedConstraints);
+    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.
-  SmallVector<const Expr *, 3> TemplateAC;
-  Template->getAssociatedConstraints(TemplateAC);
-  return CheckConstraintSatisfaction(Template, TemplateAC, 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/SemaType.cpp

case DeclaratorContext::LambdaExprParameterContext:
         // template parameter type. Template parameters are temporarily added
         // to the TU until the associated TemplateDecl is created.
         TemplateTypeParmDecl *CorrespondingTemplateParam =
             TemplateTypeParmDecl::Create(
                 SemaRef.Context, SemaRef.Context.getTranslationUnitDecl(),
                 /*KeyLoc*/ SourceLocation(), /*NameLoc*/ D.getBeginLoc(),
                 TemplateParameterDepth, AutoParameterPosition,
                 /*Identifier*/ nullptr, false, IsParameterPack,
-                /*HasTypeConstraint=*/false);
+                /*OwnsTypeConstraint=*/false);
         LSI->AutoTemplateParams.push_back(CorrespondingTemplateParam);
         // Replace the 'auto' in the function parameter with this invented
         // template type parameter.
         // FIXME: Retain some type sugar to indicate that this was written
         // as 'auto'.
         T = state.ReplaceAutoType(
             T, QualType(CorrespondingTemplateParam->getTypeForDecl(), 0));
       }

lib/Sema/TreeTransform.h

#include "clang/Basic/AttrList.inc"
   TransformDeclarationNameInfo(const DeclarationNameInfo &NameInfo);
 
   bool TransformRequiresExprRequirements(ArrayRef<Requirement *> Reqs,
       llvm::SmallVectorImpl<Requirement *> &Transformed);
   TypeRequirement *TransformTypeRequirement(TypeRequirement *Req);
   ExprRequirement *TransformExprRequirement(ExprRequirement *Req);
   NestedRequirement *TransformNestedRequirement(NestedRequirement *Req);
 
+  ExprResult TransformConstraintExpr(Expr *Constraint) {
+    return getDerived().TransformExpr(Constraint);
+  }
+
   /// Transform the given template name.
   ///
   /// \param SS The nested-name-specifier that qualifies the template
   /// name. This nested-name-specifier must already have been transformed.
   ///
   /// \param Name The template name to transform.
   ///
   /// \param NameLoc The source location of the template name.

   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>
if (NewCallOpType.isNull())
       return ExprError();
     NewCallOpTSI = NewCallOpTLBuilder.getTypeSourceInfo(getSema().Context,
                                                         NewCallOpType);
   }
 
   // Transform the trailing requires clause
   ExprResult NewTrailingRequiresClause;
   if (Expr *TRC = E->getCallOperator()->getTrailingRequiresClause())
-    // FIXME: Concepts: Substitution into requires clause should only happen
-    //                  when checking satisfaction.
-    NewTrailingRequiresClause = getDerived().TransformExpr(TRC);
+    NewTrailingRequiresClause = getDerived().TransformConstraintExpr(TRC);
 
   LambdaScopeInfo *LSI = getSema().PushLambdaScope();
   Sema::FunctionScopeRAII FuncScopeCleanup(getSema());
   LSI->GLTemplateParameterList = TPL;
 
   // Create the local class that will describe the lambda.
   CXXRecordDecl *Class
     = getSema().createLambdaClosureType(E->getIntroducerRange(),

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::VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D) {
   VisitTypeDecl(D);
 
   D->setDeclaredWithTypename(Record.readInt());
 
   if (Record.readInt()) {
+    if (Record.readInt()) {
         NestedNameSpecifierLoc NNS = Record.readNestedNameSpecifierLoc();
         DeclarationNameInfo DN;
         Record.readDeclarationNameInfo(DN);
         ConceptDecl *NamedConcept = cast<ConceptDecl>(Record.readDecl());
         const ASTTemplateArgumentListInfo *ArgsAsWritten =
             Record.readASTTemplateArgumentListInfo();
         Expr *ImmediatelyDeclaredConstraint = Record.readExpr();
         D->setTypeConstraint(NNS, DN, /*FoundDecl=*/nullptr, NamedConcept,
                              ArgsAsWritten, ImmediatelyDeclaredConstraint);
     }
+    else
+      D->setInheritedTypeConstraint(
+          Record.readDeclAs<TemplateTypeParmDecl>());
+  }
 
   if (Record.readInt())
     D->setDefaultArgument(GetTypeSourceInfo());
 }
 
 void ASTDeclReader::VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D) {
   VisitDeclaratorDecl(D);
   // TemplateParmPosition.
case DECL_VAR_TEMPLATE_PARTIAL_SPECIALIZATION:
     break;
   case DECL_CLASS_SCOPE_FUNCTION_SPECIALIZATION:
     D = ClassScopeFunctionSpecializationDecl::CreateDeserialized(Context, ID);
     break;
   case DECL_FUNCTION_TEMPLATE:
     D = FunctionTemplateDecl::CreateDeserialized(Context, ID);
     break;
   case DECL_TEMPLATE_TYPE_PARM: {
-    bool HasTypeConstraint = Record.readInt();
+    bool OwnsTypeConstraint = Record.readInt();
     D = TemplateTypeParmDecl::CreateDeserialized(Context, ID,
-                                                 HasTypeConstraint);
+                                                 OwnsTypeConstraint);
     break;
   }
   case DECL_NON_TYPE_TEMPLATE_PARM:
     D = NonTypeTemplateParmDecl::CreateDeserialized(Context, ID);
     break;
   case DECL_EXPANDED_NON_TYPE_TEMPLATE_PARM_PACK:
     D = NonTypeTemplateParmDecl::CreateDeserialized(Context, ID,
                                                     Record.readInt());

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()) {
-          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::VisitFunctionTemplateDecl(FunctionTemplateDecl *D) {
   VisitRedeclarableTemplateDecl(D);
 
   if (D->isFirstDecl())
     AddTemplateSpecializations(D);
   Code = serialization::DECL_FUNCTION_TEMPLATE;
 }
 
 void ASTDeclWriter::VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D) {
-  Record.push_back(D->hasTypeConstraint());
+  Record.push_back(D->hasTypeConstraint() && !D->typeConstraintWasInherited());
   VisitTypeDecl(D);
 
   Record.push_back(D->wasDeclaredWithTypename());
 
   const TypeConstraint *TC = D->getTypeConstraint();
   Record.push_back(TC != nullptr);
   if (TC) {
+    bool OwnsTC = !D->typeConstraintWasInherited();
+    Record.push_back(OwnsTC);
+    if (OwnsTC) {
         Record.AddNestedNameSpecifierLoc(TC->getNestedNameSpecifierLoc());
         Record.AddDeclarationNameInfo(TC->getConceptNameInfo());
         Record.AddDeclRef(TC->getNamedConcept());
         Record.AddASTTemplateArgumentListInfo(TC->getTemplateArgsAsWritten());
         Record.AddStmt(TC->getImmediatelyDeclaredConstraint());
+    } else
+      Record.AddDeclRef(D->getInheritedFromTypeConstraintDecl());
   }
 
   bool OwnsDefaultArg = D->hasDefaultArgument() &&
                         !D->defaultArgumentWasInherited();
   Record.push_back(OwnsDefaultArg);
   if (OwnsDefaultArg)
     Record.AddTypeSourceInfo(D->getDefaultArgumentInfo());
 

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.lambda/expr.prim.lambda.closure/p3.cpp

 // expected-note@-1{{candidate template ignored: constraints not satisfied [with $0 = <char>]}}
 // expected-note@-2{{candidate template ignored: constraints not satisfied [with $0 = <int, char>]}}
 // expected-note@-3 2{{because 'sizeof(decltype(x)) >= 2' (1 >= 2) evaluated to false}}
 
 auto l2t1 = l2('a');
 // expected-error@-1{{no matching function for call to object of type '(lambda at}}
 auto l2t2 = l2(1, 'a');
 // expected-error@-1{{no matching function for call to object of type '(lambda at}}
-auto l2t3 = l2((short)1, (short)1);
+auto l2t3 = l2((short)1, (short)1);
+
+template<typename T>
+struct invalid { using T::adslkdsa; };
+
+template<typename T>
+struct S {
+  inline static auto l3 = [] (auto x) requires (sizeof(decltype(invalid<T>{} + x)) == 0) {};
+};
+
+S<int> s1;

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

 
 using r14i1 = r14<const short***, const short*>;
 using r14i2 = r14<const short*, const short*>; // expected-error{{constraints not satisfied for class template 'r14' [with T = const short *, U = const short *]}}
 
 #endif
 
 // Substitution failure in type constraint
 
-template<typename T> requires requires (T t) { { t } -> Same<typename T::type>; } // expected-note{{because 'Same<expr-type, typename T::type>' would be invalid: type 'int' cannot be used prior to '::' because it has no members}}
+template<typename T> requires requires (T t) { { t } -> Same<typename T::type>; } // expected-note{{because 'Same<typename T::type>' would be invalid: type 'int' cannot be used prior to '::' because it has no members}}
 struct r15 {};
 
 using r15i1 = r15<M>;
 using r15i2 = r15<int>; // expected-error{{constraints not satisfied for class template 'r15' [with T = int]}}
 
 // Substitution failure in both expression and return type requirement
 
 template<typename T> requires requires (T t) { { t.foo() } -> Same<typename T::type>; } // expected-note{{because 't.foo()' would be invalid: member reference base type 'int' is not a structure or union}}
template<typename T> concept C5 =
     requires(T x) {
       {g(x)} noexcept; // expected-note{{because 'g(x)' may throw an exception}}
     };
 
   static_assert(C5<char>);
   template<C5 T> struct C5_check {}; // expected-note{{because 'short' does not satisfy 'C5'}}
   using c5 = C5_check<short>; // expected-error{{constraints not satisfied for class template 'C5_check' [with T = short]}}
 }
 No newline at end of file

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(U{});
+
 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 <template <typename...> class C>
 struct S3;
 
 template <C T>
 using N = typename T::type;
 
 using s31 = S3<N>;
 using s32 = S3<Z>;
+
+template<typename T, template<G<T>> class P> struct S4 { };
+// expected-note@-1{{'P' declared here}}
+
+S4<int, U> s41;
+S4<void, U> s42; // expected-error{{template template argument 'U' must not be more constrained than template template parameter 'P'}}
+
+template<typename T>
+struct S5 {
+  template<typename U, template<G<U(T)>> class P> struct S { };
+  // expected-note@-1 2{{'P' declared here}}
+};
+
+S5<int>::S<int, V> s51;
+S5<int>::S<double, V> s52; // expected-error{{template template argument 'V' must not be more constrained than template template parameter 'P'}}
+S5<double>::S<int, V> s53; // expected-error{{template template argument 'V' must not be more constrained than template template parameter 'P'}}

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

 // RUN: %clang_cc1 -std=c++2a -fconcepts-ts -x c++ -verify %s
-#if 0
+
 template<typename T> requires (sizeof(T) >= 2) // expected-note{{because 'sizeof(char) >= 2' (1 >= 2) evaluated to false}}
 struct A {
   static constexpr int value = sizeof(T);
 };
 
 static_assert(A<int>::value == 4);
 static_assert(A<char>::value == 1); // expected-error{{constraints not satisfied for class template 'A' [with T = char]}}
 
 template<typename T, typename U>
   requires (sizeof(T) != sizeof(U) // expected-note{{because 'sizeof(int) != sizeof(char [4])' (4 != 4) evaluated to false}}
             && sizeof(T) >= 4) // expected-note{{because 'sizeof(char) >= 4' (1 >= 4) evaluated to false}}
 constexpr int SizeDiff = sizeof(T) > sizeof(U) ? sizeof(T) - sizeof(U) : sizeof(U) - sizeof(T);
 
 static_assert(SizeDiff<int, char> == 3);
 static_assert(SizeDiff<int, char[4]> == 0); // expected-error{{constraints not satisfied for variable template 'SizeDiff' [with T = int, U = char [4]]}}
 static_assert(SizeDiff<char, int> == 3); // expected-error{{constraints not satisfied for variable template 'SizeDiff' [with T = char, U = int]}}
-#endif
+
 template<typename... Ts>
   requires ((sizeof(Ts) == 4) || ...) // expected-note{{because 'sizeof(char) == 4' (1 == 4) evaluated to false}} expected-note{{'sizeof(long long) == 4' (8 == 4) evaluated to false}} expected-note{{'sizeof(int [20]) == 4' (80 == 4) evaluated to false}}
 constexpr auto SumSizes = (sizeof(Ts) + ...);
 
 static_assert(SumSizes<char, long long, int> == 13);
 static_assert(SumSizes<char, long long, int[20]> == 89); // expected-error{{constraints not satisfied for variable template 'SumSizes' [with Ts = <char, long long, int [20]>]}}
-#if 0
+
 template<typename T>
 concept IsBig = sizeof(T) > 100; // expected-note{{because 'sizeof(int) > 100' (4 > 100) evaluated to false}}
 
 template<typename T>
   requires IsBig<T> // expected-note{{'int' does not satisfy 'IsBig'}}
 using BigPtr = T*;
 
 static_assert(sizeof(BigPtr<int>)); // expected-error{{constraints not satisfied for alias template 'BigPtr' [with T = int]}}}}
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}}
-#endif
+
+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/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.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}}
 }
 
 namespace maybe_incorrect_args_after_subst {
   template<typename T, typename U>
   concept C1 = true;
 
   template<typename... Us>
   concept C2 = C1<Us...>;
 
   // no diagnostic expected here - C1<Us...> is treated as atomic, and since it
   // originates at the same source level construct, the specialized subsumes the
   // primary.
   template<typename... Ts> requires C2<Ts...>
   struct A {};
 
   template<typename... Ts> requires C2<Ts...> && true
   struct A<Ts...> {};
 }
+
+namespace unreferenced_parameters {
+  template <typename T> constexpr bool B = true;
+  template <typename T, typename U> concept C0 = B<T>;
+  template <typename T, typename U> concept C1 = C0<T, U> && C0<U, T>;
+
+  template <typename T, typename U> requires C1<T, T> struct A;
+  template <typename T, typename U> requires C1<T, U> struct A<T, U>;
+}
 No newline at end of file

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

 
 // 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 r8 {};
 
   using r8i = r8<int, unsigned int>; // expected-error{{constraints not satisfied for class template 'r8' [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 {};