CbC/CbC_gcc: gcc/cp/constraint.cc comparison

comparison gcc/cp/constraint.cc @ 145:1830386684a0

gcc-9.2.0

author	anatofuz
date	Thu, 13 Feb 2020 11:34:05 +0900
parents	84e7813d76e9
children

comparison

equal deleted inserted replaced

-:84e7813d76e9
+:1830386684a0
 /* Processing rules for constraints.
-Copyright (C) 2013-2018 Free Software Foundation, Inc.
+Copyright (C) 2013-2020 Free Software Foundation, Inc.
 Contributed by Andrew Sutton (andrew.n.sutton@gmail.com)
 This file is part of GCC.
 GCC is free software; you can redistribute it and/or modify
 #include "tree-inline.h"
 #include "decl.h"
 #include "toplev.h"
 #include "type-utils.h"
+static tree satisfaction_value (tree t);
+/* When we're parsing or substuting a constraint expression, we have slightly
+different expression semantics.  In particular, we don't want to reduce a
+concept-id to a satisfaction value.  */
+processing_constraint_expression_sentinel::
+processing_constraint_expression_sentinel ()
+{
+++scope_chain->x_processing_constraint;
+}
+processing_constraint_expression_sentinel::
+~processing_constraint_expression_sentinel ()
+{
+--scope_chain->x_processing_constraint;
+}
+bool
+processing_constraint_expression_p ()
+{
+return scope_chain->x_processing_constraint != 0;
+}
 /*---------------------------------------------------------------------------
-Operations on constraints
+		       Constraint expressions
 ---------------------------------------------------------------------------*/
-/* Returns true if C is a constraint tree code. Note that ERROR_MARK
+/* Information provided to substitution.  */
-is a valid constraint.  */
+struct subst_info
+{
+subst_info (tsubst_flags_t cmp, tree in)
+: complain (cmp), in_decl (in)
+{ }
+/* True if we should not diagnose errors.  */
+bool quiet() const
+{
+return complain == tf_none;
+}
+/* True if we should diagnose errors.  */
+bool noisy() const
+{
+return !quiet ();
+}
+tsubst_flags_t complain;
+tree in_decl;
+};
+static tree satisfy_constraint (tree, tree, subst_info);
+/* True if T is known to be some type other than bool. Note that this
+is false for dependent types and errors.  */
 static inline bool
-constraint_p (tree_code c)
+known_non_bool_p (tree t)
 {
-return ((PRED_CONSTR <= c && c <= DISJ_CONSTR)
+return (t && !WILDCARD_TYPE_P (t) && TREE_CODE (t) != BOOLEAN_TYPE);
-|| c == EXPR_PACK_EXPANSION
+}
-|| c == ERROR_MARK);
-}
+static bool
+check_constraint_atom (cp_expr expr)
-/* Returns true if T is a constraint. Note that error_mark_node
+{
-is a valid constraint.  */
+if (known_non_bool_p (TREE_TYPE (expr)))
+{
-bool
+error_at (expr.get_location (),
-constraint_p (tree t)
+		"constraint expression does not have type %<bool%>");
-{
+return false;
-return constraint_p (TREE_CODE (t));
+}
-}
+/* Check that we're using function concepts correctly.  */
-/* Returns the conjunction of two constraints A and B. Note that
+if (concept_check_p (expr))
-conjoining a non-null constraint with NULL_TREE is an identity
+{
-operation. That is, for non-null A,
+tree id = unpack_concept_check (expr);
+tree tmpl = TREE_OPERAND (id, 0);
-conjoin_constraints(a, NULL_TREE) == a
+if (OVL_P (tmpl) && TREE_CODE (expr) == TEMPLATE_ID_EXPR)
+{
-and
+	  error_at (EXPR_LOC_OR_LOC (expr, input_location),
+		    "function concept must be called");
-conjoin_constraints (NULL_TREE, a) == a
+	  return false;
+	}
-If both A and B are NULL_TREE, the result is also NULL_TREE. */
+}
-tree
+return true;
-conjoin_constraints (tree a, tree b)
+}
-{
-gcc_assert (a ? constraint_p (a) : true);
+static bool
-gcc_assert (b ? constraint_p (b) : true);
+check_constraint_operands (location_t, cp_expr lhs, cp_expr rhs)
-if (a)
+{
-return b ? build_nt (CONJ_CONSTR, a, b) : a;
+return check_constraint_atom (lhs) && check_constraint_atom (rhs);
-else if (b)
+}
-return b;
-else
+/* Validate the semantic properties of the constraint expression.  */
-return NULL_TREE;
-}
+static cp_expr
+finish_constraint_binary_op (location_t loc,
-/* Transform the vector of expressions in the T into a conjunction
+			     tree_code code,
-of requirements. T must be a TREE_VEC. */
+			     cp_expr lhs,
+			     cp_expr rhs)
-tree
+{
-conjoin_constraints (tree t)
+gcc_assert (processing_constraint_expression_p ());
-{
+if (lhs == error_mark_node || rhs == error_mark_node)
-gcc_assert (TREE_CODE (t) == TREE_VEC);
+return error_mark_node;
-tree r = NULL_TREE;
+if (!check_constraint_operands (loc, lhs, rhs))
-for (int i = 0; i < TREE_VEC_LENGTH (t); ++i)
+return error_mark_node;
-r = conjoin_constraints (r, TREE_VEC_ELT (t, i));
+tree overload;
-return r;
+tree expr = build_x_binary_op (loc, code,
-}
+				 lhs, TREE_CODE (lhs),
+				 rhs, TREE_CODE (rhs),
-/* Returns true if T is a call expression to a function
+				 &overload, tf_none);
-concept. */
+/* When either operand is dependent, the overload set may be non-empty.  */
+if (expr == error_mark_node)
-bool
+return error_mark_node;
-function_concept_check_p (tree t)
+SET_EXPR_LOCATION (expr, loc);
-{
+return expr;
-gcc_assert (TREE_CODE (t) == CALL_EXPR);
+}
-tree fn = CALL_EXPR_FN (t);
-if (fn != NULL_TREE
+cp_expr
-&& TREE_CODE (fn) == TEMPLATE_ID_EXPR)
+finish_constraint_or_expr (location_t loc, cp_expr lhs, cp_expr rhs)
 {
-tree f1 = OVL_FIRST (TREE_OPERAND (fn, 0));
+return finish_constraint_binary_op (loc, TRUTH_ORIF_EXPR, lhs, rhs);
-if (TREE_CODE (f1) == TEMPLATE_DECL
+}
-	  && DECL_DECLARED_CONCEPT_P (DECL_TEMPLATE_RESULT (f1)))
-return true;
+cp_expr
-}
+finish_constraint_and_expr (location_t loc, cp_expr lhs, cp_expr rhs)
-return false;
+{
-}
+return finish_constraint_binary_op (loc, TRUTH_ANDIF_EXPR, lhs, rhs);
+}
-/* Returns true if any of the arguments in the template
-argument list is a wildcard or wildcard pack.  */
+cp_expr
+finish_constraint_primary_expr (cp_expr expr)
+{
+if (expr == error_mark_node)
+return error_mark_node;
+if (!check_constraint_atom (expr))
+return cp_expr (error_mark_node, expr.get_location ());
+return expr;
+}
+/* Combine two constraint-expressions with a logical-and.  */
+tree
+combine_constraint_expressions (tree lhs, tree rhs)
+{
+processing_constraint_expression_sentinel pce;
+if (!lhs)
+return rhs;
+if (!rhs)
+return lhs;
+return finish_constraint_and_expr (input_location, lhs, rhs);
+}
+/* Extract the template-id from a concept check. For standard and variable
+checks, this is simply T. For function concept checks, this is the
+called function.  */
+tree
+unpack_concept_check (tree t)
+{
+gcc_assert (concept_check_p (t));
+if (TREE_CODE (t) == CALL_EXPR)
+t = CALL_EXPR_FN (t);
+gcc_assert (TREE_CODE (t) == TEMPLATE_ID_EXPR);
+return t;
+}
+/* Extract the TEMPLATE_DECL from a concept check.  */
+tree
+get_concept_check_template (tree t)
+{
+tree id = unpack_concept_check (t);
+tree tmpl = TREE_OPERAND (id, 0);
+if (OVL_P (tmpl))
+tmpl = OVL_FIRST (tmpl);
+return tmpl;
+}
+/* Returns true if any of the arguments in the template argument list is
+a wildcard or wildcard pack.  */
 bool
 contains_wildcard_p (tree args)
 {
 for (int i = 0; i < TREE_VEC_LENGTH (args); ++i)
 	return true;
 }
 return false;
 }
-/* Build a new call expression, but don't actually generate a
-new function call. We just want the tree, not the semantics.  */
-inline tree
-build_call_check (tree id)
-{
-++processing_template_decl;
-vec<tree, va_gc> *fargs = make_tree_vector();
-tree call = finish_call_expr (id, &fargs, false, false, tf_none);
-release_tree_vector (fargs);
---processing_template_decl;
-return call;
-}
-/* Build an expression that will check a variable concept. If any
-argument contains a wildcard, don't try to finish the variable
-template because we can't substitute into a non-existent
-declaration.  */
-tree
-build_variable_check (tree id)
-{
-gcc_assert (TREE_CODE (id) == TEMPLATE_ID_EXPR);
-if (contains_wildcard_p (TREE_OPERAND (id, 1)))
-return id;
-++processing_template_decl;
-tree var = finish_template_variable (id);
---processing_template_decl;
-return var;
-}
 /*---------------------------------------------------------------------------
 Resolution of qualified concept names
 ---------------------------------------------------------------------------*/
-/* This facility is used to resolve constraint checks from
+/* This facility is used to resolve constraint checks from requirement
-requirement expressions. A constraint check is a call to
+expressions. A constraint check is a call to a function template declared
-a function template declared with the keyword 'concept'.
+with the keyword 'concept'.
-The result of resolution is a pair (a TREE_LIST) whose value
+The result of resolution is a pair (a TREE_LIST) whose value is the
-is the matched declaration, and whose purpose contains the
+matched declaration, and whose purpose contains the coerced template
-coerced template arguments that can be substituted into the
+arguments that can be substituted into the call.  */
-call.  */
+/* Given an overload set OVL, try to find a unique definition that can be
-// Given an overload set OVL, try to find a unique definition that can be
+instantiated by the template arguments ARGS.
-// instantiated by the template arguments ARGS.
-//
+This function is not called for arbitrary call expressions. In particular,
-// This function is not called for arbitrary call expressions. In particular,
+the call expression must be written with explicit template arguments
-// the call expression must be written with explicit template arguments
+and no function arguments. For example:
-// and no function arguments. For example:
-//
+f<T, U>()
-//      f<T, U>()
-//
+If a single match is found, this returns a TREE_LIST whose VALUE
-// If a single match is found, this returns a TREE_LIST whose VALUE
+is the constraint function (not the template), and its PURPOSE is
-// is the constraint function (not the template), and its PURPOSE is
+the complete set of arguments substituted into the parameter list.  */
-// the complete set of arguments substituted into the parameter list.
 static tree
-resolve_constraint_check (tree ovl, tree args)
+resolve_function_concept_overload (tree ovl, tree args)
 {
 int nerrs = 0;
 tree cands = NULL_TREE;
 for (lkp_iterator iter (ovl); iter; ++iter)
 {
-// Get the next template overload.
 tree tmpl = *iter;
 if (TREE_CODE (tmpl) != TEMPLATE_DECL)
 continue;
-// Don't try to deduce checks for non-concepts. We often
+/* Don't try to deduce checks for non-concepts. We often end up trying
-// end up trying to resolve constraints in functional casts
+to resolve constraints in functional casts as part of a
-// as part of a postfix-expression. We can save time and
+postfix-expression. We can save time and headaches by not
-// headaches by not instantiating those declarations.
+instantiating those declarations.
-//
-// NOTE: This masks a potential error, caused by instantiating
+NOTE: This masks a potential error, caused by instantiating
-// non-deduced contexts using placeholder arguments.
+non-deduced contexts using placeholder arguments. */
 tree fn = DECL_TEMPLATE_RESULT (tmpl);
 if (DECL_ARGUMENTS (fn))
 continue;
 if (!DECL_DECLARED_CONCEPT_P (fn))
 continue;
-// Remember the candidate if we can deduce a substitution.
+/* Remember the candidate if we can deduce a substitution.  */
 ++processing_template_decl;
 tree parms = TREE_VALUE (DECL_TEMPLATE_PARMS (tmpl));
 if (tree subst = coerce_template_parms (parms, args, tmpl))
 {
 if (subst == error_mark_node)
 return error_mark_node;
 return cands;
 }
-// Determine if the the call expression CALL is a constraint check, and
+/* Determine if the the call expression CALL is a constraint check, and
-// return the concept declaration and arguments being checked. If CALL
+return the concept declaration and arguments being checked. If CALL
-// does not denote a constraint check, return NULL.
+does not denote a constraint check, return NULL.  */
-tree
-resolve_constraint_check (tree call)
+tree
+resolve_function_concept_check (tree call)
 {
 gcc_assert (TREE_CODE (call) == CALL_EXPR);
-// A constraint check must be only a template-id expression. If
+/* A constraint check must be only a template-id expression.
-// it's a call to a base-link, its function(s) should be a
+If it's a call to a base-link, its function(s) should be a
-// template-id expression. If this is not a template-id, then it
+template-id expression. If this is not a template-id, then
-// cannot be a concept-check.
+it cannot be a concept-check.  */
 tree target = CALL_EXPR_FN (call);
 if (BASELINK_P (target))
 target = BASELINK_FUNCTIONS (target);
 if (TREE_CODE (target) != TEMPLATE_ID_EXPR)
 return NULL_TREE;
-// Get the overload set and template arguments and try to
+/* Get the overload set and template arguments and try to
-// resolve the target.
+resolve the target.  */
 tree ovl = TREE_OPERAND (target, 0);
-/* This is a function call of a variable concept... ill-formed. */
+/* This is a function call of a variable concept... ill-formed.  */
 if (TREE_CODE (ovl) == TEMPLATE_DECL)
 {
 error_at (location_of (call),
 		"function call of variable concept %qE", call);
 return error_mark_node;
 }
 tree args = TREE_OPERAND (target, 1);
-return resolve_constraint_check (ovl, args);
+return resolve_function_concept_overload (ovl, args);
 }
-/* Returns a pair containing the checked variable concept
+/* Returns a pair containing the checked concept and its associated
-and its associated prototype parameter.  The result
+prototype parameter. The result is a TREE_LIST whose TREE_VALUE
-is a TREE_LIST whose TREE_VALUE is the variable concept
+is the concept (non-template) and whose TREE_PURPOSE contains
-and whose TREE_PURPOSE is the prototype parameter.  */
+the converted template arguments, including the deduced prototype
+parameter (in position 0). */
-tree
-resolve_variable_concept_check (tree id)
+tree
-{
+resolve_concept_check (tree check)
+{
+gcc_assert (concept_check_p (check));
+tree id = unpack_concept_check (check);
 tree tmpl = TREE_OPERAND (id, 0);
+/* If this is an overloaded function concept, perform overload
+resolution (this only happens when deducing prototype parameters
+and template introductions).  */
+if (TREE_CODE (tmpl) == OVERLOAD)
+{
+if (OVL_CHAIN (tmpl))
+	return resolve_function_concept_check (check);
+tmpl = OVL_FIRST (tmpl);
+}
 tree args = TREE_OPERAND (id, 1);
-if (!variable_concept_p (tmpl))
-return NULL_TREE;
-/* Make sure that we have the right parameters before
-assuming that it works.  Note that failing to deduce
-will result in diagnostics.  */
 tree parms = INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (tmpl));
 ++processing_template_decl;
 tree result = coerce_template_parms (parms, args, tmpl);
 --processing_template_decl;
-if (result != error_mark_node)
+if (result == error_mark_node)
-{
-tree decl = DECL_TEMPLATE_RESULT (tmpl);
-return build_tree_list (result, decl);
-}
-else
 return error_mark_node;
-}
+return build_tree_list (result, DECL_TEMPLATE_RESULT (tmpl));
+}
-/* Given a call expression or template-id expression to
+/* Given a call expression or template-id expression to a concept EXPR
-a concept EXPR possibly including a wildcard, deduce
+possibly including a wildcard, deduce the concept being checked and
-the concept being checked and the prototype parameter.
+the prototype parameter. Returns true if the constraint and prototype
-Returns true if the constraint and prototype can be
+can be deduced and false otherwise.  Note that the CHECK and PROTO
-deduced and false otherwise.  Note that the CHECK and
+arguments are set to NULL_TREE if this returns false.  */
-PROTO arguments are set to NULL_TREE if this returns
-false.  */
 bool
 deduce_constrained_parameter (tree expr, tree& check, tree& proto)
 {
-tree info = NULL_TREE;
+tree info = resolve_concept_check (expr);
-if (TREE_CODE (expr) == TEMPLATE_ID_EXPR)
-info = resolve_variable_concept_check (expr);
-else if (TREE_CODE (expr) == CALL_EXPR)
-info = resolve_constraint_check (expr);
-else
-gcc_unreachable ();
 if (info && info != error_mark_node)
 {
 check = TREE_VALUE (info);
 tree arg = TREE_VEC_ELT (TREE_PURPOSE (info), 0);
 if (ARGUMENT_PACK_P (arg))
 	arg = TREE_VEC_ELT (ARGUMENT_PACK_ARGS (arg), 0);
 proto = TREE_TYPE (arg);
 return true;
 }
 check = proto = NULL_TREE;
 return false;
 }
-// Given a call expression or template-id expression to a concept, EXPR,
+/* Given a call expression or template-id expression to a concept, EXPR,
-// deduce the concept being checked and return the template arguments.
+deduce the concept being checked and return the template arguments.
-// Returns NULL_TREE if deduction fails.
+Returns NULL_TREE if deduction fails.  */
 static tree
-deduce_concept_introduction (tree expr)
+deduce_concept_introduction (tree check)
 {
-tree info = NULL_TREE;
+tree info = resolve_concept_check (check);
-if (TREE_CODE (expr) == TEMPLATE_ID_EXPR)
-info = resolve_variable_concept_check (expr);
-else if (TREE_CODE (expr) == CALL_EXPR)
-info = resolve_constraint_check (expr);
-else
-gcc_unreachable ();
 if (info && info != error_mark_node)
 return TREE_PURPOSE (info);
 return NULL_TREE;
 }
-namespace {
+/* Build a constrained placeholder type where SPEC is a type-constraint.
+SPEC can be anything were concept_definition_p is true.
-/*---------------------------------------------------------------------------
-Constraint implication learning
+If DECLTYPE_P is true, then the placeholder is decltype(auto).
----------------------------------------------------------------------------*/
+Returns a pair whose FIRST is the concept being checked and whose
-/* The implication context determines how we memoize concept checks.
+SECOND is the prototype parameter.  */
-Given two checks C1 and C2, the direction of implication depends
-on whether we are learning implications of a conjunction or disjunction.
+tree_pair
-For example:
+finish_type_constraints (tree spec, tree args, tsubst_flags_t complain)
+{
-template<typename T> concept bool C = ...;
+gcc_assert (concept_definition_p (spec));
-template<typenaem T> concept bool D = C<T> && true;
+/* Build an initial concept check.  */
-From this, we can learn that D<T> implies C<T>. We cannot learn,
+tree check = build_type_constraint (spec, args, complain);
-without further testing, that C<T> does not imply D<T>. If, for
+if (check == error_mark_node)
-example, C<T> were defined as true, then these constraints would
+return std::make_pair (error_mark_node, NULL_TREE);
-be logically equivalent.
+/* Extract the concept and prototype parameter from the check. */
-In rare cases, we may start with a logical equivalence. For example:
+tree con;
+tree proto;
-template<typename T> concept bool C = ...;
+if (!deduce_constrained_parameter (check, con, proto))
-template<typename T> concept bool D = C<T>;
+return std::make_pair (error_mark_node, NULL_TREE);
-Here, we learn that C<T> implies D<T> and vice versa.   */
+return std::make_pair (con, proto);
-enum implication_context
-{
-conjunction_cxt, /* C1 implies C2. */
-disjunction_cxt, /* C2 implies C1. */
-equivalence_cxt  /* C1 implies C2, C2 implies C1. */
-};
-void learn_implications(tree, tree, implication_context);
-void
-learn_implication (tree parent, tree child, implication_context cxt)
-{
-switch (cxt)
-{
-case conjunction_cxt:
-save_subsumption_result (parent, child, true);
-break;
-case disjunction_cxt:
-save_subsumption_result (child, parent, true);
-break;
-case equivalence_cxt:
-save_subsumption_result (parent, child, true);
-save_subsumption_result (child, parent, true);
-break;
-}
-}
-void
-learn_logical_operation (tree parent, tree constr, implication_context cxt)
-{
-learn_implications (parent, TREE_OPERAND (constr, 0), cxt);
-learn_implications (parent, TREE_OPERAND (constr, 1), cxt);
-}
-void
-learn_implications (tree parent, tree constr, implication_context cxt)
-{
-switch (TREE_CODE (constr))
-{
-case CHECK_CONSTR:
-return learn_implication (parent, constr, cxt);
-case CONJ_CONSTR:
-if (cxt == disjunction_cxt)
-return;
-return learn_logical_operation (parent, constr, cxt);
-case DISJ_CONSTR:
-if (cxt == conjunction_cxt)
-return;
-return learn_logical_operation (parent, constr, cxt);
-default:
-break;
-}
-}
-/* Quickly scan the top-level constraints of CONSTR to learn and
-cache logical relations between concepts.  The search does not
-include conjunctions of disjunctions or vice versa.  */
-void
-learn_implications (tree tmpl, tree args, tree constr)
-{
-/* Don't memoize relations between non-dependent arguemnts. It's not
-helpful. */
-if (!uses_template_parms (args))
-return;
-/* Build a check constraint for the purpose of caching. */
-tree parent = build_nt (CHECK_CONSTR, tmpl, args);
-/* Start learning based on the kind of the top-level contraint. */
-if (TREE_CODE (constr) == CONJ_CONSTR)
-return learn_logical_operation (parent, constr, conjunction_cxt);
-else if (TREE_CODE (constr) == DISJ_CONSTR)
-return learn_logical_operation (parent, constr, disjunction_cxt);
-else if (TREE_CODE (constr) == CHECK_CONSTR)
-/* This is the rare concept alias case. */
-return learn_implication (parent, constr, equivalence_cxt);
 }
 /*---------------------------------------------------------------------------
 Expansion of concept definitions
 ---------------------------------------------------------------------------*/
 /* Returns the expression of a function concept. */
-tree
+static tree
 get_returned_expression (tree fn)
 {
 /* Extract the body of the function minus the return expression.  */
 tree body = DECL_SAVED_TREE (fn);
 if (!body)
 return TREE_OPERAND (body, 0);
 }
 /* Returns the initializer of a variable concept. */
-tree
+static tree
 get_variable_initializer (tree var)
 {
 tree init = DECL_INITIAL (var);
 if (!init)
 return error_mark_node;
+if (BRACE_ENCLOSED_INITIALIZER_P (init)
+&& CONSTRUCTOR_NELTS (init) == 1)
+init = CONSTRUCTOR_ELT (init, 0)->value;
 return init;
 }
 /* Returns the definition of a variable or function concept.  */
-tree
+static tree
 get_concept_definition (tree decl)
 {
+if (TREE_CODE (decl) == OVERLOAD)
+decl = OVL_FIRST (decl);
+if (TREE_CODE (decl) == TEMPLATE_DECL)
+decl = DECL_TEMPLATE_RESULT (decl);
+if (TREE_CODE (decl) == CONCEPT_DECL)
+return DECL_INITIAL (decl);
 if (VAR_P (decl))
 return get_variable_initializer (decl);
-else if (TREE_CODE (decl) == FUNCTION_DECL)
+if (TREE_CODE (decl) == FUNCTION_DECL)
 return get_returned_expression (decl);
 gcc_unreachable ();
 }
-int expansion_level = 0;
+/*---------------------------------------------------------------------------
+		      Normalization of expressions
-struct expanding_concept_sentinel
-{
+This set of functions will transform an expression into a constraint
-expanding_concept_sentinel ()
+in a sequence of steps.
+---------------------------------------------------------------------------*/
+void
+debug_parameter_mapping (tree map)
+{
+for (tree p = map; p; p = TREE_CHAIN (p))
+{
+tree parm = TREE_VALUE (p);
+tree arg = TREE_PURPOSE (p);
+if (TYPE_P (parm))
+	verbatim ("MAP %qD TO %qT", TEMPLATE_TYPE_DECL (parm), arg);
+else
+	verbatim ("MAP %qD TO %qE", TEMPLATE_PARM_DECL (parm), arg);
+// debug_tree (parm);
+// debug_tree (arg);
+}
+}
+void
+debug_argument_list (tree args)
+{
+for (int i = 0; i < TREE_VEC_LENGTH (args); ++i)
+{
+tree arg = TREE_VEC_ELT (args, i);
+if (TYPE_P (arg))
+	verbatim ("ARG %qT", arg);
+else
+	verbatim ("ARG %qE", arg);
+}
+}
+/* Associate each parameter in PARMS with its corresponding template
+argument in ARGS.  */
+static tree
+map_arguments (tree parms, tree args)
+{
+for (tree p = parms; p; p = TREE_CHAIN (p))
+{
+int level;
+int index;
+template_parm_level_and_index (TREE_VALUE (p), &level, &index);
+TREE_PURPOSE (p) = TMPL_ARG (args, level, index);
+}
+return parms;
+}
+/* Build the parameter mapping for EXPR using ARGS.  */
+static tree
+build_parameter_mapping (tree expr, tree args, tree decl)
+{
+tree ctx_parms = NULL_TREE;
+if (decl)
+{
+gcc_assert (TREE_CODE (decl) == TEMPLATE_DECL);
+ctx_parms = DECL_TEMPLATE_PARMS (decl);
+}
+else if (current_template_parms)
+{
+/* TODO: This should probably be the only case, but because the
+	 point of declaration of concepts is currently set after the
+	 initializer, the template parameter lists are not available
+	 when normalizing concept definitions, hence the case above.  */
+ctx_parms = current_template_parms;
+}
+tree parms = find_template_parameters (expr, ctx_parms);
+tree map = map_arguments (parms, args);
+return map;
+}
+/* True if the parameter mappings of two atomic constraints are equivalent.  */
+static bool
+parameter_mapping_equivalent_p (tree t1, tree t2)
+{
+tree map1 = ATOMIC_CONSTR_MAP (t1);
+tree map2 = ATOMIC_CONSTR_MAP (t2);
+while (map1 && map2)
+{
+tree arg1 = TREE_PURPOSE (map1);
+tree arg2 = TREE_PURPOSE (map2);
+if (!template_args_equal (arg1, arg2))
+return false;
+map1 = TREE_CHAIN (map1);
+map2 = TREE_CHAIN (map2);
+}
+return true;
+}
+/* Provides additional context for normalization.  */
+struct norm_info : subst_info
+{
+explicit norm_info (tsubst_flags_t complain)
+: subst_info (tf_warning_or_error | complain, NULL_TREE),
+context()
+{}
+/* Construct a top-level context for DECL.  */
+norm_info (tree in_decl, tsubst_flags_t complain)
+: subst_info (tf_warning_or_error | complain, in_decl),
+context (make_context (in_decl))
+{}
+bool generate_diagnostics() const
 {
-++expansion_level;
+return complain & tf_norm;
 }
-~expanding_concept_sentinel()
+tree make_context(tree in_decl)
 {
---expansion_level;
+if (generate_diagnostics ())
+return build_tree_list (NULL_TREE, in_decl);
+return NULL_TREE;
 }
+void update_context(tree expr, tree args)
+{
+if (generate_diagnostics ())
+{
+	tree map = build_parameter_mapping (expr, args, in_decl);
+	context = tree_cons (map, expr, context);
+}
+in_decl = get_concept_check_template (expr);
+}
+/* Provides information about the source of a constraint. This is a
+TREE_LIST whose VALUE is either a concept check or a constrained
+declaration. The PURPOSE, for concept checks is a parameter mapping
+for that check.  */
+tree context;
 };
+static tree normalize_expression (tree, tree, norm_info);
-} /* namespace */
-/* Returns true when a concept is being expanded.  */
-bool
-expanding_concept()
-{
-return expansion_level > 0;
-}
-/* Expand a concept declaration (not a template) and its arguments to
-a constraint defined by the concept's initializer or definition.  */
-tree
-expand_concept (tree decl, tree args)
-{
-expanding_concept_sentinel sentinel;
-if (TREE_CODE (decl) == TEMPLATE_DECL)
-decl = DECL_TEMPLATE_RESULT (decl);
-tree tmpl = DECL_TI_TEMPLATE (decl);
-/* Check for a previous specialization. */
-if (tree spec = get_concept_expansion (tmpl, args))
-return spec;
-/* Substitute the arguments to form a new definition expression.  */
-tree def = get_concept_definition (decl);
-++processing_template_decl;
-tree result = tsubst_expr (def, args, tf_none, NULL_TREE, true);
---processing_template_decl;
-if (result == error_mark_node)
-return error_mark_node;
-/* And lastly, normalize it, check for implications, and save
-the specialization for later.  */
-tree norm = normalize_expression (result);
-learn_implications (tmpl, args, norm);
-return save_concept_expansion (tmpl, args, norm);
-}
-/*---------------------------------------------------------------------------
-Stepwise normalization of expressions
-This set of functions will transform an expression into a constraint
-in a sequence of steps. Normalization does not not look into concept
-definitions.
----------------------------------------------------------------------------*/
 /* Transform a logical-or or logical-and expression into either
 a conjunction or disjunction. */
-tree
+static tree
-normalize_logical_operation (tree t, tree_code c)
+normalize_logical_operation (tree t, tree args, tree_code c, norm_info info)
 {
-tree t0 = normalize_expression (TREE_OPERAND (t, 0));
+tree t0 = normalize_expression (TREE_OPERAND (t, 0), args, info);
-tree t1 = normalize_expression (TREE_OPERAND (t, 1));
+tree t1 = normalize_expression (TREE_OPERAND (t, 1), args, info);
-return build_nt (c, t0, t1);
-}
+/* Build a new info object for the constraint.  */
+tree ci = info.generate_diagnostics()
-/* A simple requirement T introduces an expression constraint
+? build_tree_list (t, info.context)
-for its expression. */
+: NULL_TREE;
-inline tree
+return build2 (c, ci, t0, t1);
-normalize_simple_requirement (tree t)
+}
-{
-return build_nt (EXPR_CONSTR, TREE_OPERAND (t, 0));
+static tree
-}
+normalize_concept_check (tree check, tree args, norm_info info)
+{
-/* A type requirement T introduce a type constraint for its type.  */
+tree id = unpack_concept_check (check);
+tree tmpl = TREE_OPERAND (id, 0);
-inline tree
+tree targs = TREE_OPERAND (id, 1);
-normalize_type_requirement (tree t)
-{
+/* A function concept is wrapped in an overload.  */
-return build_nt (TYPE_CONSTR, TREE_OPERAND (t, 0));
+if (TREE_CODE (tmpl) == OVERLOAD)
-}
+{
+/* TODO: Can we diagnose this error during parsing?  */
-/* A compound requirement T introduces a conjunction of constraints
+if (TREE_CODE (check) == TEMPLATE_ID_EXPR)
-depending on its form.  The conjunction always includes an
+	error_at (EXPR_LOC_OR_LOC (check, input_location),
-expression constraint for the expression of the requirement.
+		  "function concept must be called");
-If a trailing return type was specified, the conjunction includes
+tmpl = OVL_FIRST (tmpl);
-either an implicit conversion constraint or an argument deduction
+}
-constraint.  If the noexcept specifier is present, the conjunction
-includes an exception constraint.  */
+/* Substitute through the arguments of the concept check. */
+targs = tsubst_template_args (targs, args, info.complain, info.in_decl);
-tree
+if (targs == error_mark_node)
-normalize_compound_requirement (tree t)
+return error_mark_node;
-{
-tree expr = TREE_OPERAND (t, 0);
+/* Build the substitution for the concept definition.  */
-tree constr = build_nt (EXPR_CONSTR, TREE_OPERAND (t, 0));
+tree parms = TREE_VALUE (DECL_TEMPLATE_PARMS (tmpl));
+/* Turn on template processing; coercing non-type template arguments
-/* If a type is given, append an implicit conversion or
+will automatically assume they're non-dependent.  */
-argument deduction constraint.  */
+++processing_template_decl;
-if (tree type = TREE_OPERAND (t, 1))
+tree subst = coerce_template_parms (parms, targs, tmpl);
-{
+--processing_template_decl;
-tree type_constr;
+if (subst == error_mark_node)
-/* TODO: We should be extracting a list of auto nodes
+return error_mark_node;
-from type_uses_auto, not a single node */
-if (tree placeholder = type_uses_auto (type))
+/* The concept may have been ill-formed.  */
-type_constr = build_nt (DEDUCT_CONSTR, expr, type, placeholder);
+tree def = get_concept_definition (DECL_TEMPLATE_RESULT (tmpl));
-else
+if (def == error_mark_node)
-type_constr = build_nt (ICONV_CONSTR, expr, type);
+return error_mark_node;
-constr = conjoin_constraints (constr, type_constr);
-}
+info.update_context (check, args);
+return normalize_expression (def, subst, info);
-/* If noexcept is present, append an exception constraint. */
-if (COMPOUND_REQ_NOEXCEPT_P (t))
-{
-tree except = build_nt (EXCEPT_CONSTR, expr);
-constr = conjoin_constraints (constr, except);
-}
-return constr;
-}
-/* A nested requirement T introduces a conjunction of constraints
-corresponding to its constraint-expression.
-If the result of transforming T is error_mark_node, the resulting
-constraint is a predicate constraint whose operand is also
-error_mark_node. This preserves the constraint structure, but
-will guarantee that the constraint is never satisfied.  */
-inline tree
-normalize_nested_requirement (tree t)
-{
-return normalize_expression (TREE_OPERAND (t, 0));
-}
-/* Transform a requirement T into one or more constraints.  */
-tree
-normalize_requirement (tree t)
-{
-switch (TREE_CODE (t))
-{
-case SIMPLE_REQ:
-return normalize_simple_requirement (t);
-case TYPE_REQ:
-return normalize_type_requirement (t);
-case COMPOUND_REQ:
-return normalize_compound_requirement (t);
-case NESTED_REQ:
-return normalize_nested_requirement (t);
-default:
-gcc_unreachable ();
-}
-return error_mark_node;
-}
-/* Transform a sequence of requirements into a conjunction of
-constraints. */
-tree
-normalize_requirements (tree t)
-{
-tree result = NULL_TREE;
-for (; t; t = TREE_CHAIN (t))
-{
-tree constr = normalize_requirement (TREE_VALUE (t));
-result = conjoin_constraints (result, constr);
-}
-return result;
-}
-/* The normal form of a requires-expression is a parameterized
-constraint having the same parameters and a conjunction of
-constraints representing the normal form of requirements.  */
-tree
-normalize_requires_expression (tree t)
-{
-tree operand = normalize_requirements (TREE_OPERAND (t, 1));
-if (tree parms = TREE_OPERAND (t, 0))
-return build_nt (PARM_CONSTR, parms, operand);
-else
-return operand;
-}
-/* For a template-id referring to a variable concept, returns
-a check constraint. Otherwise, returns a predicate constraint. */
-tree
-normalize_template_id_expression (tree t)
-{
-if (tree info = resolve_variable_concept_check (t))
-{
-if (info == error_mark_node)
-{
-/* We get this when the template arguments don't match
-the variable concept. */
-error ("invalid reference to concept %qE", t);
-return error_mark_node;
-}
-tree decl = TREE_VALUE (info);
-tree args = TREE_PURPOSE (info);
-return build_nt (CHECK_CONSTR, decl, args);
-}
-/* Check that we didn't refer to a function concept like a variable.  */
-tree fn = OVL_FIRST (TREE_OPERAND (t, 0));
-if (TREE_CODE (fn) == TEMPLATE_DECL
-&& DECL_DECLARED_CONCEPT_P (DECL_TEMPLATE_RESULT (fn)))
-{
-error_at (location_of (t),
-		"invalid reference to function concept %qD", fn);
-return error_mark_node;
-}
-return build_nt (PRED_CONSTR, t);
-}
-/* For a call expression to a function concept, returns a check
-constraint. Otherwise, returns a predicate constraint. */
-tree
-normalize_call_expression (tree t)
-{
-/* Try to resolve this function call as a concept.  If not, then
-it can be returned as a predicate constraint.  */
-tree check = resolve_constraint_check (t);
-if (!check)
-return build_nt (PRED_CONSTR, t);
-if (check == error_mark_node)
-{
-/* TODO: Improve diagnostics. We could report why the reference
-is invalid. */
-error ("invalid reference to concept %qE", t);
-return error_mark_node;
-}
-tree fn = TREE_VALUE (check);
-tree args = TREE_PURPOSE (check);
-return build_nt (CHECK_CONSTR, fn, args);
-}
-/* If T is a call to an overloaded && or || operator, diagnose that
-as a non-SFINAEable error.  Returns true if an error is emitted.
-TODO: It would be better to diagnose this at the point of definition,
-if possible. Perhaps we should immediately do a first-pass normalization
-of a concept definition to catch obvious non-dependent errors like
-this.  */
-bool
-check_for_logical_overloads (tree t)
-{
-if (TREE_CODE (t) != CALL_EXPR)
-return false;
-tree fn = CALL_EXPR_FN (t);
-/* For member calls, try extracting the function from the
-component ref.  */
-if (TREE_CODE (fn) == COMPONENT_REF)
-{
-fn = TREE_OPERAND (fn, 1);
-if (TREE_CODE (fn) == BASELINK)
-fn = BASELINK_FUNCTIONS (fn);
-}
-if (TREE_CODE (fn) != FUNCTION_DECL)
-return false;
-if (DECL_OVERLOADED_OPERATOR_P (fn))
-{
-location_t loc = cp_expr_loc_or_loc (t, input_location);
-error_at (loc, "constraint %qE, uses overloaded operator", t);
-return true;
-}
-return false;
 }
 /* The normal form of an atom depends on the expression. The normal
 form of a function call to a function concept is a check constraint
 for that concept. The normal form of a reference to a variable
 concept is a check constraint for that concept. Otherwise, the
 constraint is a predicate constraint.  */
-tree
+static tree
-normalize_atom (tree t)
+normalize_atom (tree t, tree args, norm_info info)
 {
-/* We can get constraints pushed down through pack expansions, so
+/* Concept checks are not atomic.  */
-just return them. */
+if (concept_check_p (t))
-if (constraint_p (t))
+return normalize_concept_check (t, args, info);
-return t;
+/* Build the parameter mapping for the atom.  */
-tree type = TREE_TYPE (t);
+tree map = build_parameter_mapping (t, args, info.in_decl);
-if (!type || type_unknown_p (t) || TREE_CODE (type) == TEMPLATE_TYPE_PARM)
-;
+/* Build a new info object for the atom.  */
-else if (!dependent_type_p (type))
+tree ci = build_tree_list (t, info.context);
-{
-if (check_for_logical_overloads (t))
+return build1 (ATOMIC_CONSTR, ci, map);
-return error_mark_node;
+}
-type = cv_unqualified (type);
+/* Returns the normal form of an expression. */
-if (!same_type_p (type, boolean_type_node))
-	{
+static tree
-	  error ("predicate constraint %q+E does not have type %<bool%>", t);
+normalize_expression (tree t, tree args, norm_info info)
-	  return error_mark_node;
-	}
-}
-if (TREE_CODE (t) == TEMPLATE_ID_EXPR)
-return normalize_template_id_expression (t);
-if (TREE_CODE (t) == CALL_EXPR)
-return normalize_call_expression (t);
-return build_nt (PRED_CONSTR, t);
-}
-/* Push down the pack expansion EXP into the leaves of the constraint PAT.  */
-tree
-push_down_pack_expansion (tree exp, tree pat)
-{
-switch (TREE_CODE (pat))
-{
-case CONJ_CONSTR:
-case DISJ_CONSTR:
-{
-	pat = copy_node (pat);
-	TREE_OPERAND (pat, 0)
-	  = push_down_pack_expansion (exp, TREE_OPERAND (pat, 0));
-	TREE_OPERAND (pat, 1)
-	  = push_down_pack_expansion (exp, TREE_OPERAND (pat, 1));
-	return pat;
-}
-default:
-{
-	exp = copy_node (exp);
-	SET_PACK_EXPANSION_PATTERN (exp, pat);
-	return exp;
-}
-}
-}
-/* Transform a pack expansion into a constraint.  First we transform the
-pattern of the pack expansion, then we push the pack expansion down into the
-leaves of the constraint so that partial ordering will work.  */
-tree
-normalize_pack_expansion (tree t)
-{
-tree pat = normalize_expression (PACK_EXPANSION_PATTERN (t));
-return push_down_pack_expansion (t, pat);
-}
-/* Transform an expression into a constraint.  */
-tree
-normalize_any_expression (tree t)
-{
-switch (TREE_CODE (t))
-{
-case TRUTH_ANDIF_EXPR:
-return normalize_logical_operation (t, CONJ_CONSTR);
-case TRUTH_ORIF_EXPR:
-return normalize_logical_operation (t, DISJ_CONSTR);
-case REQUIRES_EXPR:
-return normalize_requires_expression (t);
-case BIND_EXPR:
-return normalize_expression (BIND_EXPR_BODY (t));
-case EXPR_PACK_EXPANSION:
-return normalize_pack_expansion (t);
-default:
-/* All other constraints are atomic. */
-return normalize_atom (t);
-}
-}
-/* Transform a statement into an expression.  */
-tree
-normalize_any_statement (tree t)
-{
-switch (TREE_CODE (t))
-{
-case RETURN_EXPR:
-return normalize_expression (TREE_OPERAND (t, 0));
-default:
-gcc_unreachable ();
-}
-return error_mark_node;
-}
-/* Reduction rules for the declaration T.  */
-tree
-normalize_any_declaration (tree t)
-{
-switch (TREE_CODE (t))
-{
-case VAR_DECL:
-return normalize_atom (t);
-default:
-gcc_unreachable ();
-}
-return error_mark_node;
-}
-/* Returns the normal form of a constraint expression. */
-tree
-normalize_expression (tree t)
 {
 if (!t)
 return NULL_TREE;
 if (t == error_mark_node)
 return error_mark_node;
-switch (TREE_CODE_CLASS (TREE_CODE (t)))
+switch (TREE_CODE (t))
 {
-case tcc_unary:
+case TRUTH_ANDIF_EXPR:
-case tcc_binary:
+return normalize_logical_operation (t, args, CONJ_CONSTR, info);
-case tcc_expression:
+case TRUTH_ORIF_EXPR:
-case tcc_vl_exp:
+return normalize_logical_operation (t, args, DISJ_CONSTR, info);
-return normalize_any_expression (t);
-case tcc_statement:
-return normalize_any_statement (t);
-case tcc_declaration:
-return normalize_any_declaration (t);
-case tcc_exceptional:
-case tcc_constant:
-case tcc_reference:
-case tcc_comparison:
-/* These are all atomic predicate constraints. */
-return normalize_atom (t);
 default:
-/* Unhandled node kind. */
+return normalize_atom (t, args, info);
-gcc_unreachable ();
+}
 }
-return error_mark_node;
-}
+/* Cache of the normalized form of constraints.  Marked as deletable because it
+can all be recalculated.  */
+static GTY((deletable)) hash_map<tree,tree> *normalized_map;
-/*---------------------------------------------------------------------------
-Constraint normalization
+static tree
----------------------------------------------------------------------------*/
+get_normalized_constraints (tree t, tree args, norm_info info)
+{
-tree normalize_constraint (tree);
+auto_timevar time (TV_CONSTRAINT_NORM);
+return normalize_expression (t, args, info);
-/* The normal form of the disjunction T0 /\ T1 is the conjunction
+}
-of the normal form of T0 and the normal form of T1.  */
+/* Returns the normalized constraints from a constraint-info object
-inline tree
+or NULL_TREE if the constraints are null. ARGS provide the initial
-normalize_conjunction (tree t)
+arguments for normalization and IN_DECL provides the declaration
-{
+to which the constraints belong.  */
-tree t0 = normalize_constraint (TREE_OPERAND (t, 0));
-tree t1 = normalize_constraint (TREE_OPERAND (t, 1));
+static tree
-return build_nt (CONJ_CONSTR, t0, t1);
+get_normalized_constraints_from_info (tree ci, tree args, tree in_decl,
-}
+				      bool diag = false)
+{
-/* The normal form of the disjunction T0 \/ T1 is the disjunction
+if (ci == NULL_TREE)
-of the normal form of T0 and the normal form of T1.  */
+return NULL_TREE;
-inline tree
+/* Substitution errors during normalization are fatal.  */
-normalize_disjunction (tree t)
-{
-tree t0 = normalize_constraint (TREE_OPERAND (t, 0));
-tree t1 = normalize_constraint (TREE_OPERAND (t, 1));
-return build_nt (DISJ_CONSTR, t0, t1);
-}
-/* A predicate constraint is normalized in two stages.  First all
-references specializations of concepts are replaced by their
-substituted definitions.  Then, the resulting expression is
-transformed into a constraint by transforming && expressions
-into conjunctions and || into disjunctions.  */
-tree
-normalize_predicate_constraint (tree t)
-{
 ++processing_template_decl;
-tree expr = PRED_CONSTR_EXPR (t);
+norm_info info (in_decl, diag ? tf_norm : tf_none);
-tree constr = normalize_expression (expr);
+tree t = get_normalized_constraints (CI_ASSOCIATED_CONSTRAINTS (ci),
+				       args, info);
 --processing_template_decl;
-return constr;
-}
+return t;
+}
-/* The normal form of a parameterized constraint is the normal
-form of its operand.  */
+/* Returns the normalized constraints for the declaration D.  */
-tree
+static tree
-normalize_parameterized_constraint (tree t)
+get_normalized_constraints_from_decl (tree d, bool diag = false)
 {
-tree parms = PARM_CONSTR_PARMS (t);
+tree tmpl;
-tree operand = normalize_constraint (PARM_CONSTR_OPERAND (t));
+tree decl;
-return build_nt (PARM_CONSTR, parms, operand);
-}
+/* For inherited constructors, consider the original declaration;
+it has the correct template information attached. */
-/* Normalize the constraint T by reducing it so that it is
+d = strip_inheriting_ctors (d);
-comprised of only conjunctions and disjunctions of atomic
-constraints.  */
+if (TREE_CODE (d) == TEMPLATE_DECL)
+{
-tree
+tmpl = d;
-normalize_constraint (tree t)
+decl = DECL_TEMPLATE_RESULT (tmpl);
-{
+}
-if (!t)
+else
-return NULL_TREE;
+{
+if (tree ti = DECL_TEMPLATE_INFO (d))
-if (t == error_mark_node)
+	tmpl = TI_TEMPLATE (ti);
-return t;
+else
+	tmpl = NULL_TREE;
+decl = d;
+}
+/* Get the most general template for the declaration, and compute
+arguments from that. This ensures that the arguments used for
+normalization are always template parameters and not arguments
+used for outer specializations.  For example:
+template<typename T>
+struct S {
+	  template<typename U> requires C<T, U> void f(U);
+};
+S<int>::f(0);
+When we normalize the requirements for S<int>::f, we want the
+arguments to be {T, U}, not {int, U}. One reason for this is that
+accepting the latter causes the template parameter level of U
+to be reduced in a way that makes it overly difficult substitute
+concrete arguments (i.e., eventually {int, int} during satisfaction.  */
+if (tmpl)
+{
+if (DECL_LANG_SPECIFIC(tmpl) && !DECL_TEMPLATE_SPECIALIZATION (tmpl))
+tmpl = most_general_template (tmpl);
+}
+/* If we're not diagnosing errors, use cached constraints, if any.  */
+if (!diag)
+if (tree *p = hash_map_safe_get (normalized_map, tmpl))
+return *p;
+tree args = generic_targs_for (tmpl);
+tree ci = get_constraints (decl);
+tree norm = get_normalized_constraints_from_info (ci, args, tmpl, diag);
+if (!diag)
+hash_map_safe_put<hm_ggc> (normalized_map, tmpl, norm);
+return norm;
+}
+/* Returns the normal form of TMPL's definition.  */
+static tree
+normalize_concept_definition (tree tmpl, bool diag = false)
+{
+if (!diag)
+if (tree *p = hash_map_safe_get (normalized_map, tmpl))
+return *p;
+gcc_assert (concept_definition_p (tmpl));
+if (OVL_P (tmpl))
+tmpl = OVL_FIRST (tmpl);
+gcc_assert (TREE_CODE (tmpl) == TEMPLATE_DECL);
+tree args = generic_targs_for (tmpl);
+tree def = get_concept_definition (DECL_TEMPLATE_RESULT (tmpl));
+++processing_template_decl;
+norm_info info (tmpl, diag ? tf_norm : tf_none);
+tree norm = get_normalized_constraints (def, args, info);
+--processing_template_decl;
+if (!diag)
+hash_map_safe_put<hm_ggc> (normalized_map, tmpl, norm);
+return norm;
+}
+/* Returns the normal form of TMPL's requirements.  */
+static tree
+normalize_template_requirements (tree tmpl, bool diag = false)
+{
+return get_normalized_constraints_from_decl (tmpl, diag);
+}
+/* Returns the normal form of TMPL's requirements.  */
+static tree
+normalize_nontemplate_requirements (tree decl, bool diag = false)
+{
+return get_normalized_constraints_from_decl (decl, diag);
+}
+/* Normalize an EXPR as a constraint using ARGS.  */
+static tree
+normalize_constraint_expression (tree expr, tree args, bool diag = false)
+{
+if (!expr || expr == error_mark_node)
+return expr;
+++processing_template_decl;
+norm_info info (diag ? tf_norm : tf_none);
+tree norm = get_normalized_constraints (expr, args, info);
+--processing_template_decl;
+return norm;
+}
+/* Normalize an EXPR as a constraint.  */
+static tree
+normalize_constraint_expression (tree expr, bool diag = false)
+{
+if (!expr || expr == error_mark_node)
+return expr;
+/* For concept checks, use the supplied template arguments as those used
+for normalization. Otherwise, there are no template arguments.  */
+tree args;
+if (concept_check_p (expr))
+{
+tree id = unpack_concept_check (expr);
+args = TREE_OPERAND (id, 1);
+}
+else
+args = NULL_TREE;
+return normalize_constraint_expression (expr, args, diag);
+}
+/* 17.4.1.2p2. Two constraints are identical if they are formed
+from the same expression and the targets of the parameter mapping
+are equivalent.  */
+bool
+atomic_constraints_identical_p (tree t1, tree t2)
+{
+gcc_assert (TREE_CODE (t1) == ATOMIC_CONSTR);
+gcc_assert (TREE_CODE (t2) == ATOMIC_CONSTR);
+if (ATOMIC_CONSTR_EXPR (t1) != ATOMIC_CONSTR_EXPR (t2))
+return false;
+if (!parameter_mapping_equivalent_p (t1, t2))
+return false;
+return true;
+}
+/* True if T1 and T2 are equivalent, meaning they have the same syntactic
+structure and all corresponding constraints are identical.  */
+bool
+constraints_equivalent_p (tree t1, tree t2)
+{
+gcc_assert (CONSTR_P (t1));
+gcc_assert (CONSTR_P (t2));
+if (TREE_CODE (t1) != TREE_CODE (t2))
+return false;
+switch (TREE_CODE (t1))
+{
+case CONJ_CONSTR:
+case DISJ_CONSTR:
+if (!constraints_equivalent_p (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0)))
+return false;
+if (!constraints_equivalent_p (TREE_OPERAND (t1, 1), TREE_OPERAND (t2, 1)))
+return false;
+break;
+case ATOMIC_CONSTR:
+if (!atomic_constraints_identical_p(t1, t2))
+return false;
+break;
+default:
+gcc_unreachable ();
+}
+return true;
+}
+/* Compute the hash value for T.  */
+hashval_t
+hash_atomic_constraint (tree t)
+{
+gcc_assert (TREE_CODE (t) == ATOMIC_CONSTR);
+/* Hash the identity of the expression.  */
+hashval_t val = htab_hash_pointer (ATOMIC_CONSTR_EXPR (t));
+/* Hash the targets of the parameter map.  */
+tree p = ATOMIC_CONSTR_MAP (t);
+while (p)
+{
+val = iterative_hash_template_arg (TREE_PURPOSE (p), val);
+p = TREE_CHAIN (p);
+}
+return val;
+}
+namespace inchash
+{
+static void
+add_constraint (tree t, hash& h)
+{
+h.add_int(TREE_CODE (t));
 switch (TREE_CODE (t))
 {
 case CONJ_CONSTR:
-return normalize_conjunction (t);
+case DISJ_CONSTR:
+add_constraint (TREE_OPERAND (t, 0), h);
-case DISJ_CONSTR:
+add_constraint (TREE_OPERAND (t, 1), h);
-return normalize_disjunction (t);
+break;
+case ATOMIC_CONSTR:
-case PRED_CONSTR:
+h.merge_hash (hash_atomic_constraint (t));
-return normalize_predicate_constraint (t);
+break;
+default:
-case PARM_CONSTR:
+gcc_unreachable ();
-return normalize_parameterized_constraint (t);
+}
+}
-case EXPR_CONSTR:
-case TYPE_CONSTR:
+}
-case ICONV_CONSTR:
-case DEDUCT_CONSTR:
+/* Computes a hash code for the constraint T.  */
-case EXCEPT_CONSTR:
-/* These constraints are defined to be atomic. */
+hashval_t
-return t;
+iterative_hash_constraint (tree t, hashval_t val)
+{
-default:
+gcc_assert (CONSTR_P (t));
-/* CONSTR was not a constraint. */
+inchash::hash h (val);
-gcc_unreachable();
+inchash::add_constraint (t, h);
-}
+return h.end ();
-return error_mark_node;
+}
-}
 // -------------------------------------------------------------------------- //
 // Constraint Semantic Processing
 //
 // The following functions are called by the parser and substitution rules
 tree
 current_template_constraints (void)
 {
 if (!current_template_parms)
 return NULL_TREE;
-tree tmpl_constr = TEMPLATE_PARM_CONSTRAINTS (current_template_parms);
+tree tmpl_constr = TEMPLATE_PARMS_CONSTRAINTS (current_template_parms);
 return build_constraints (tmpl_constr, NULL_TREE);
 }
-// If the recently parsed TYPE declares or defines a template or template
+/* If the recently parsed TYPE declares or defines a template or
-// specialization, get its corresponding constraints from the current
+template specialization, get its corresponding constraints from the
-// template parameters and bind them to TYPE's declaration.
+current template parameters and bind them to TYPE's declaration.  */
 tree
 associate_classtype_constraints (tree type)
 {
-if (!type || type == error_mark_node || TREE_CODE (type) != RECORD_TYPE)
+if (!type || type == error_mark_node || !CLASS_TYPE_P (type))
 return type;
-// An explicit class template specialization has no template
+/* An explicit class template specialization has no template parameters.  */
-// parameters.
 if (!current_template_parms)
 return type;
 if (CLASSTYPE_IS_TEMPLATE (type) || CLASSTYPE_TEMPLATE_SPECIALIZATION (type))
 {
 tree decl = TYPE_STUB_DECL (type);
 tree ci = current_template_constraints ();
-// An implicitly instantiated member template declaration already
+/* An implicitly instantiated member template declaration already
-// has associated constraints. If it is defined outside of its
+	 has associated constraints. If it is defined outside of its
-// class, then we need match these constraints against those of
+	 class, then we need match these constraints against those of
-// original declaration.
+	 original declaration.  */
 if (tree orig_ci = get_constraints (decl))
 {
 if (!equivalent_constraints (ci, orig_ci))
 {
-// FIXME: Improve diagnostics.
+	      error ("%qT does not match original declaration", type);
-error ("%qT does not match any declaration", type);
+	      tree tmpl = CLASSTYPE_TI_TEMPLATE (type);
-return error_mark_node;
+	      location_t loc = DECL_SOURCE_LOCATION (tmpl);
+	      inform (loc, "original template declaration here");
+	      /* Fall through, so that we define the type anyway.  */
 }
 return type;
 }
 set_constraints (decl, ci);
 }
 return type;
 }
-namespace {
+/* Create an empty constraint info block.  */
-// Create an empty constraint info block.
+static inline tree_constraint_info*
-inline tree_constraint_info*
 build_constraint_info ()
 {
 return (tree_constraint_info *)make_node (CONSTRAINT_INFO);
 }
-} // namespace
 /* Build a constraint-info object that contains the associated constraints
 of a declaration.  This also includes the declaration's template
 requirements (TREQS) and any trailing requirements for a function
 declarator (DREQS).  Note that both TREQS and DREQS must be constraints.
 If the declaration has neither template nor declaration requirements
 this returns NULL_TREE, indicating an unconstrained declaration.  */
 tree
-build_constraints (tree tmpl_reqs, tree decl_reqs)
+build_constraints (tree tr, tree dr)
 {
-gcc_assert (tmpl_reqs ? constraint_p (tmpl_reqs) : true);
+if (!tr && !dr)
-gcc_assert (decl_reqs ? constraint_p (decl_reqs) : true);
-if (!tmpl_reqs && !decl_reqs)
 return NULL_TREE;
 tree_constraint_info* ci = build_constraint_info ();
-ci->template_reqs = tmpl_reqs;
+ci->template_reqs = tr;
-ci->declarator_reqs = decl_reqs;
+ci->declarator_reqs = dr;
-ci->associated_constr = conjoin_constraints (tmpl_reqs, decl_reqs);
+ci->associated_constr = combine_constraint_expressions (tr, dr);
 return (tree)ci;
 }
-namespace {
+/* Add constraint RHS to the end of CONSTRAINT_INFO ci.  */
+tree
+append_constraint (tree ci, tree rhs)
+{
+tree tr = ci ? CI_TEMPLATE_REQS (ci) : NULL_TREE;
+tree dr = ci ? CI_DECLARATOR_REQS (ci) : NULL_TREE;
+dr = combine_constraint_expressions (dr, rhs);
+if (ci)
+{
+CI_DECLARATOR_REQS (ci) = dr;
+tree ac = combine_constraint_expressions (tr, dr);
+CI_ASSOCIATED_CONSTRAINTS (ci) = ac;
+}
+else
+ci = build_constraints (tr, dr);
+return ci;
+}
+/* A mapping from declarations to constraint information.  */
+static GTY ((cache)) decl_tree_cache_map *decl_constraints;
+/* Returns the template constraints of declaration T. If T is not
+constrained, return NULL_TREE. Note that T must be non-null. */
+tree
+get_constraints (const_tree t)
+{
+if (!flag_concepts)
+return NULL_TREE;
+if (!decl_constraints)
+return NULL_TREE;
+gcc_assert (DECL_P (t));
+if (TREE_CODE (t) == TEMPLATE_DECL)
+t = DECL_TEMPLATE_RESULT (t);
+tree* found = decl_constraints->get (CONST_CAST_TREE (t));
+if (found)
+return *found;
+else
+return NULL_TREE;
+}
+/* Associate the given constraint information CI with the declaration
+T. If T is a template, then the constraints are associated with
+its underlying declaration. Don't build associations if CI is
+NULL_TREE.  */
+void
+set_constraints (tree t, tree ci)
+{
+if (!ci)
+return;
+gcc_assert (t && flag_concepts);
+if (TREE_CODE (t) == TEMPLATE_DECL)
+t = DECL_TEMPLATE_RESULT (t);
+bool found = hash_map_safe_put<hm_ggc> (decl_constraints, t, ci);
+gcc_assert (!found);
+}
+/* Remove the associated constraints of the declaration T.  */
+void
+remove_constraints (tree t)
+{
+gcc_assert (DECL_P (t));
+if (TREE_CODE (t) == TEMPLATE_DECL)
+t = DECL_TEMPLATE_RESULT (t);
+if (decl_constraints)
+decl_constraints->remove (t);
+}
+/* If DECL is a friend, substitute into REQS to produce requirements suitable
+for declaration matching.  */
+tree
+maybe_substitute_reqs_for (tree reqs, const_tree decl_)
+{
+if (reqs == NULL_TREE)
+return NULL_TREE;
+tree decl = CONST_CAST_TREE (decl_);
+tree result = STRIP_TEMPLATE (decl);
+if (DECL_FRIEND_P (result))
+{
+tree tmpl = decl == result ? DECL_TI_TEMPLATE (result) : decl;
+tree gargs = generic_targs_for (tmpl);
+processing_template_decl_sentinel s;
+if (uses_template_parms (gargs))
+	++processing_template_decl;
+reqs = tsubst_constraint (reqs, gargs,
+				tf_warning_or_error, NULL_TREE);
+}
+return reqs;
+}
+/* Returns the template-head requires clause for the template
+declaration T or NULL_TREE if none.  */
+tree
+get_template_head_requirements (tree t)
+{
+tree ci = get_constraints (t);
+if (!ci)
+return NULL_TREE;
+return CI_TEMPLATE_REQS (ci);
+}
+/* Returns the trailing requires clause of the declarator of
+a template declaration T or NULL_TREE if none.  */
+tree
+get_trailing_function_requirements (tree t)
+{
+tree ci = get_constraints (t);
+if (!ci)
+return NULL_TREE;
+return CI_DECLARATOR_REQS (ci);
+}
 /* Construct a sequence of template arguments by prepending
 ARG to REST. Either ARG or REST may be null. */
-tree
+static tree
 build_concept_check_arguments (tree arg, tree rest)
 {
 gcc_assert (rest ? TREE_CODE (rest) == TREE_VEC : true);
 tree args;
 if (arg)
 args = rest;
 }
 return args;
 }
-} // namespace
+/* Builds an id-expression of the form `C<Args...>()` where C is a function
+concept.  */
-/* Construct an expression that checks the concept given by
-TARGET. The TARGET must be:
+static tree
+build_function_check (tree tmpl, tree args, tsubst_flags_t /*complain*/)
-- an OVERLOAD referring to one or more function concepts
+{
-- a BASELINK referring to an overload set of the above, or
+if (TREE_CODE (tmpl) == TEMPLATE_DECL)
-- a TEMPLTATE_DECL referring to a variable concept.
+{
+/* If we just got a template, wrap it in an overload so it looks like any
-ARG and REST are the explicit template arguments for the
+	 other template-id. */
-eventual concept check. */
+tmpl = ovl_make (tmpl);
-tree
+TREE_TYPE (tmpl) = boolean_type_node;
-build_concept_check (tree target, tree arg, tree rest)
+}
-{
+/* Perform function concept resolution now so we always have a single
+function of the overload set (even if we started with only one; the
+resolution function converts template arguments). Note that we still
+wrap this in an overload set so we don't upset other parts of the
+compiler that expect template-ids referring to function concepts
+to have an overload set.  */
+tree info = resolve_function_concept_overload (tmpl, args);
+if (info == error_mark_node)
+return error_mark_node;
+if (!info)
+{
+error ("no matching concepts for %qE", tmpl);
+return error_mark_node;
+}
+args = TREE_PURPOSE (info);
+tmpl = DECL_TI_TEMPLATE (TREE_VALUE (info));
+/* Rebuild the singleton overload set; mark the type bool.  */
+tmpl = ovl_make (tmpl, NULL_TREE);
+TREE_TYPE (tmpl) = boolean_type_node;
+/* Build the id-expression around the overload set.  */
+tree id = build2 (TEMPLATE_ID_EXPR, boolean_type_node, tmpl, args);
+/* Finally, build the call expression around the overload.  */
+++processing_template_decl;
+vec<tree, va_gc> *fargs = make_tree_vector ();
+tree call = build_min_nt_call_vec (id, fargs);
+TREE_TYPE (call) = boolean_type_node;
+release_tree_vector (fargs);
+--processing_template_decl;
+return call;
+}
+/* Builds an id-expression of the form `C<Args...>` where C is a variable
+concept.  */
+static tree
+build_variable_check (tree tmpl, tree args, tsubst_flags_t complain)
+{
+gcc_assert (variable_concept_p (tmpl));
+gcc_assert (TREE_CODE (tmpl) == TEMPLATE_DECL);
+tree parms = INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (tmpl));
+args = coerce_template_parms (parms, args, tmpl, complain);
+if (args == error_mark_node)
+return error_mark_node;
+return build2 (TEMPLATE_ID_EXPR, boolean_type_node, tmpl, args);
+}
+/* Builds an id-expression of the form `C<Args...>` where C is a standard
+concept.  */
+static tree
+build_standard_check (tree tmpl, tree args, tsubst_flags_t complain)
+{
+gcc_assert (standard_concept_p (tmpl));
+gcc_assert (TREE_CODE (tmpl) == TEMPLATE_DECL);
+tree parms = INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (tmpl));
+args = coerce_template_parms (parms, args, tmpl, complain);
+if (args == error_mark_node)
+return error_mark_node;
+return build2 (TEMPLATE_ID_EXPR, boolean_type_node, tmpl, args);
+}
+/* Construct an expression that checks TARGET using ARGS.  */
+tree
+build_concept_check (tree target, tree args, tsubst_flags_t complain)
+{
+return build_concept_check (target, NULL_TREE, args, complain);
+}
+/* Construct an expression that checks the concept given by DECL. If
+concept_definition_p (DECL) is false, this returns null.  */
+tree
+build_concept_check (tree decl, tree arg, tree rest, tsubst_flags_t complain)
+{
+if (arg == NULL_TREE && rest == NULL_TREE)
+{
+tree id = build_nt (TEMPLATE_ID_EXPR, decl, rest);
+error ("invalid use concept %qE", id);
+return error_mark_node;
+}
 tree args = build_concept_check_arguments (arg, rest);
-if (variable_template_p (target))
-return build_variable_check (lookup_template_variable (target, args));
+if (standard_concept_p (decl))
-else
+return build_standard_check (decl, args, complain);
-return build_call_check (lookup_template_function (target, args));
+if (variable_concept_p (decl))
-}
+return build_variable_check (decl, args, complain);
+if (function_concept_p (decl))
+return build_function_check (decl, args, complain);
+return error_mark_node;
+}
+/* Build a template-id that can participate in a concept check.  */
+static tree
+build_concept_id (tree decl, tree args)
+{
+tree check = build_concept_check (decl, args, tf_warning_or_error);
+if (check == error_mark_node)
+return error_mark_node;
+return unpack_concept_check (check);
+}
+/* Build a template-id that can participate in a concept check, preserving
+the source location of the original template-id.  */
+tree
+build_concept_id (tree expr)
+{
+gcc_assert (TREE_CODE (expr) == TEMPLATE_ID_EXPR);
+tree id = build_concept_id (TREE_OPERAND (expr, 0), TREE_OPERAND (expr, 1));
+protected_set_expr_location (id, cp_expr_location (expr));
+return id;
+}
+/* Build as template-id with a placeholder that can be used as a
+type constraint.
+Note that this will diagnose errors if the initial concept check
+cannot be built.  */
+tree
+build_type_constraint (tree decl, tree args, tsubst_flags_t complain)
+{
+tree wildcard = build_nt (WILDCARD_DECL);
+tree check = build_concept_check (decl, wildcard, args, complain);
+if (check == error_mark_node)
+return error_mark_node;
+return unpack_concept_check (check);
+}
 /* Returns a TYPE_DECL that contains sufficient information to
 build a template parameter of the same kind as PROTO and
 constrained by the concept declaration CNC.  Note that PROTO
 is the first template parameter of CNC.
 CONSTRAINED_PARM_CONCEPT (decl) = cnc;
 CONSTRAINED_PARM_EXTRA_ARGS (decl) = args;
 return decl;
 }
-/* Create a constraint expression for the given DECL that
+/* Create a constraint expression for the given DECL that evaluates the
-evaluates the requirements specified by CONSTR, a TYPE_DECL
+requirements specified by CONSTR, a TYPE_DECL that contains all the
-that contains all the information necessary to build the
+information necessary to build the requirements (see finish_concept_name
-requirements (see finish_concept_name for the layout of
+for the layout of that TYPE_DECL).
-that TYPE_DECL).
+Note that the constraints are neither reduced nor decomposed. That is
-Note that the constraints are neither reduced nor decomposed.
+done only after the requires clause has been parsed (or not).  */
-That is done only after the requires clause has been parsed
-(or not).
-This will always return a CHECK_CONSTR. */
 tree
 finish_shorthand_constraint (tree decl, tree constr)
 {
 /* No requirements means no constraints.  */
 if (!constr)
 tree proto = CONSTRAINED_PARM_PROTOTYPE (constr);
 tree con = CONSTRAINED_PARM_CONCEPT (constr);
 tree args = CONSTRAINED_PARM_EXTRA_ARGS (constr);
-/* If the parameter declaration is variadic, but the concept
+/* The TS lets use shorthand to constrain a pack of arguments, but the
-is not then we need to apply the concept to every element
+standard does not.
-in the pack.  */
-bool is_proto_pack = template_parameter_pack_p (proto);
+For the TS, consider:
-bool is_decl_pack = template_parameter_pack_p (decl);
-bool apply_to_all_p = is_decl_pack && !is_proto_pack;
+	template<C... Ts> struct s;
+If C is variadic (and because Ts is a pack), we associate the
+constraint C<Ts...>. In all other cases, we associate
+the constraint (C<Ts> && ...).
+The standard behavior cannot be overridden by -fconcepts-ts.  */
+bool variadic_concept_p = template_parameter_pack_p (proto);
+bool declared_pack_p = template_parameter_pack_p (decl);
+bool apply_to_each_p = (cxx_dialect >= cxx2a) ? true : !variadic_concept_p;
 /* Get the argument and overload used for the requirement
 and adjust it if we're going to expand later.  */
 tree arg = template_parm_to_arg (build_tree_list (NULL_TREE, decl));
-if (apply_to_all_p)
+if (apply_to_each_p && declared_pack_p)
 arg = PACK_EXPANSION_PATTERN (TREE_VEC_ELT (ARGUMENT_PACK_ARGS (arg), 0));
-/* Build the concept check. If it the constraint needs to be
+/* Build the concept constraint-expression.  */
-applied to all elements of the parameter pack, then make
-the constraint an expansion. */
 tree tmpl = DECL_TI_TEMPLATE (con);
-tree check = VAR_P (con) ? tmpl : ovl_make (tmpl);
+tree check = tmpl;
-check = build_concept_check (check, arg, args);
+if (TREE_CODE (con) == FUNCTION_DECL)
+check = ovl_make (tmpl);
-/* Make the check a pack expansion if needed.
+check = build_concept_check (check, arg, args, tf_warning_or_error);
-FIXME: We should be making a fold expression. */
+/* Make the check a fold-expression if needed.  */
-if (apply_to_all_p)
+if (apply_to_each_p && declared_pack_p)
-{
+check = finish_left_unary_fold_expr (check, TRUTH_ANDIF_EXPR);
-check = make_pack_expansion (check);
-TREE_TYPE (check) = boolean_type_node;
+return check;
-}
-return normalize_expression (check);
 }
 /* Returns a conjunction of shorthand requirements for the template
 parameter list PARMS. Note that the requirements are stored in
 the TYPE of each tree node. */
 tree
 get_shorthand_constraints (tree parms)
 {
 tree result = NULL_TREE;
 parms = INNERMOST_TEMPLATE_PARMS (parms);
 for (int i = 0; i < TREE_VEC_LENGTH (parms); ++i)
 {
 tree parm = TREE_VEC_ELT (parms, i);
 tree constr = TEMPLATE_PARM_CONSTRAINTS (parm);
-result = conjoin_constraints (result, constr);
+result = combine_constraint_expressions (result, constr);
 }
 return result;
 }
-// Returns and chains a new parameter for PARAMETER_LIST which will conform
+/* Get the deduced wildcard from a DEDUCED placeholder.  If the deduced
-// to the prototype given by SRC_PARM.  The new parameter will have its
+wildcard is a pack, return the first argument of that pack.  */
-// identifier and location set according to IDENT and PARM_LOC respectively.
 static tree
-process_introduction_parm (tree parameter_list, tree src_parm)
+get_deduced_wildcard (tree wildcard)
 {
-// If we have a pack, we should have a single pack argument which is the
+if (ARGUMENT_PACK_P (wildcard))
-// placeholder we want to look at.
+wildcard = TREE_VEC_ELT (ARGUMENT_PACK_ARGS (wildcard), 0);
-bool is_parameter_pack = ARGUMENT_PACK_P (src_parm);
+gcc_assert (TREE_CODE (wildcard) == WILDCARD_DECL);
-if (is_parameter_pack)
+return wildcard;
-src_parm = TREE_VEC_ELT (ARGUMENT_PACK_ARGS (src_parm), 0);
+}
-// At this point we should have a wildcard, but we want to
+/* Returns the prototype parameter for the nth deduced wildcard.  */
-// grab the associated decl from it.  Also grab the stored
-// identifier and location that should be chained to it in
+static tree
-// a PARM_DECL.
+get_introduction_prototype (tree wildcards, int index)
-gcc_assert (TREE_CODE (src_parm) == WILDCARD_DECL);
+{
+return TREE_TYPE (get_deduced_wildcard (TREE_VEC_ELT (wildcards, index)));
-tree ident = DECL_NAME (src_parm);
+}
-location_t parm_loc = DECL_SOURCE_LOCATION (src_parm);
+/* Introduce a type template parameter.  */
-// If we expect a pack and the deduced template is not a pack, or if the
-// template is using a pack and we didn't declare a pack, throw an error.
+static tree
-if (is_parameter_pack != WILDCARD_PACK_P (src_parm))
+introduce_type_template_parameter (tree wildcard, bool& non_type_p)
 {
-error_at (parm_loc, "cannot match pack for introduced parameter");
+non_type_p = false;
-tree err_parm = build_tree_list (error_mark_node, error_mark_node);
+return finish_template_type_parm (class_type_node, DECL_NAME (wildcard));
-return chainon (parameter_list, err_parm);
+}
-}
+/* Introduce a template template parameter.  */
-src_parm = TREE_TYPE (src_parm);
+static tree
+introduce_template_template_parameter (tree wildcard, bool& non_type_p)
+{
+non_type_p = false;
+begin_template_parm_list ();
+current_template_parms = DECL_TEMPLATE_PARMS (TREE_TYPE (wildcard));
+end_template_parm_list ();
+return finish_template_template_parm (class_type_node, DECL_NAME (wildcard));
+}
+/* Introduce a template non-type parameter.  */
+static tree
+introduce_nontype_template_parameter (tree wildcard, bool& non_type_p)
+{
+non_type_p = true;
+tree parm = copy_decl (TREE_TYPE (wildcard));
+DECL_NAME (parm) = DECL_NAME (wildcard);
+return parm;
+}
+/* Introduce a single template parameter.  */
+static tree
+build_introduced_template_parameter (tree wildcard, bool& non_type_p)
+{
+tree proto = TREE_TYPE (wildcard);
 tree parm;
-bool is_non_type;
+if (TREE_CODE (proto) == TYPE_DECL)
-if (TREE_CODE (src_parm) == TYPE_DECL)
+parm = introduce_type_template_parameter (wildcard, non_type_p);
-{
+else if (TREE_CODE (proto) == TEMPLATE_DECL)
-is_non_type = false;
+parm = introduce_template_template_parameter (wildcard, non_type_p);
-parm = finish_template_type_parm (class_type_node, ident);
-}
-else if (TREE_CODE (src_parm) == TEMPLATE_DECL)
-{
-is_non_type = false;
-begin_template_parm_list ();
-current_template_parms = DECL_TEMPLATE_PARMS (src_parm);
-end_template_parm_list ();
-parm = finish_template_template_parm (class_type_node, ident);
-}
 else
-{
+parm = introduce_nontype_template_parameter (wildcard, non_type_p);
-is_non_type = true;
+/* Wrap in a TREE_LIST for process_template_parm. Note that introduced
-// Since we don't have a declarator, so we can copy the source
+parameters do not retain the defaults from the source parameter.  */
-// parameter and change the name and eventually the location.
+return build_tree_list (NULL_TREE, parm);
-parm = copy_decl (src_parm);
+}
-DECL_NAME (parm) = ident;
-}
+/* Introduce a single template parameter.  */
-// Wrap in a TREE_LIST for process_template_parm.  Introductions do not
+static tree
-// retain the defaults from the source template.
+introduce_template_parameter (tree parms, tree wildcard)
-parm = build_tree_list (NULL_TREE, parm);
+{
+gcc_assert (!ARGUMENT_PACK_P (wildcard));
-return process_template_parm (parameter_list, parm_loc, parm,
+tree proto = TREE_TYPE (wildcard);
-is_non_type, is_parameter_pack);
+location_t loc = DECL_SOURCE_LOCATION (wildcard);
-}
+/* Diagnose the case where we have C{...Args}.  */
-/* Associates a constraint check to the current template based
+if (WILDCARD_PACK_P (wildcard))
-on the introduction parameters.  INTRO_LIST must be a TREE_VEC
+{
-of WILDCARD_DECLs containing a chained PARM_DECL which
+tree id = DECL_NAME (wildcard);
-contains the identifier as well as the source location.
+error_at (loc, "%qE cannot be introduced with an ellipsis %<...%>", id);
-TMPL_DECL is the decl for the concept being used.  If we
+inform (DECL_SOURCE_LOCATION (proto), "prototype declared here");
-take a concept, C, this will form a check in the form of
+}
-C<INTRO_LIST> filling in any extra arguments needed by the
-defaults deduced.
+bool non_type_p;
+tree parm = build_introduced_template_parameter (wildcard, non_type_p);
-Returns NULL_TREE if no concept could be matched and
+return process_template_parm (parms, loc, parm, non_type_p, false);
-error_mark_node if an error occurred when matching.  */
+}
-tree
-finish_template_introduction (tree tmpl_decl, tree intro_list)
+/* Introduce a template parameter pack.  */
-{
-/* Deduce the concept check.  */
+static tree
-tree expr = build_concept_check (tmpl_decl, NULL_TREE, intro_list);
+introduce_template_parameter_pack (tree parms, tree wildcard)
+{
+bool non_type_p;
+tree parm = build_introduced_template_parameter (wildcard, non_type_p);
+location_t loc = DECL_SOURCE_LOCATION (wildcard);
+return process_template_parm (parms, loc, parm, non_type_p, true);
+}
+/* Introduce the nth template parameter.  */
+static tree
+introduce_template_parameter (tree parms, tree wildcards, int& index)
+{
+tree deduced = TREE_VEC_ELT (wildcards, index++);
+return introduce_template_parameter (parms, deduced);
+}
+/* Introduce either a template parameter pack or a list of template
+parameters.  */
+static tree
+introduce_template_parameters (tree parms, tree wildcards, int& index)
+{
+/* If the prototype was a parameter, we better have deduced an
+argument pack, and that argument must be the last deduced value
+in the wildcard vector.  */
+tree deduced = TREE_VEC_ELT (wildcards, index++);
+gcc_assert (ARGUMENT_PACK_P (deduced));
+gcc_assert (index == TREE_VEC_LENGTH (wildcards));
+/* Introduce each element in the pack.  */
+tree args = ARGUMENT_PACK_ARGS (deduced);
+for (int i = 0; i < TREE_VEC_LENGTH (args); ++i)
+{
+tree arg = TREE_VEC_ELT (args, i);
+if (WILDCARD_PACK_P (arg))
+	parms = introduce_template_parameter_pack (parms, arg);
+else
+	parms = introduce_template_parameter (parms, arg);
+}
+return parms;
+}
+/* Builds the template parameter list PARMS by chaining introduced
+parameters from the WILDCARD vector.  INDEX is the position of
+the current parameter.  */
+static tree
+process_introduction_parms (tree parms, tree wildcards, int& index)
+{
+tree proto = get_introduction_prototype (wildcards, index);
+if (template_parameter_pack_p (proto))
+return introduce_template_parameters (parms, wildcards, index);
+else
+return introduce_template_parameter (parms, wildcards, index);
+}
+/* Ensure that all template parameters have been introduced for the concept
+named in CHECK.  If not, emit a diagnostic.
+Note that implicitly introducing a parameter with a default argument
+creates a case where a parameter is declared, but unnamed, making
+it unusable in the definition.  */
+static bool
+check_introduction_list (tree intros, tree check)
+{
+check = unpack_concept_check (check);
+tree tmpl = TREE_OPERAND (check, 0);
+if (OVL_P (tmpl))
+tmpl = OVL_FIRST (tmpl);
+tree parms = DECL_INNERMOST_TEMPLATE_PARMS (tmpl);
+if (TREE_VEC_LENGTH (intros) < TREE_VEC_LENGTH (parms))
+{
+error_at (input_location, "all template parameters of %qD must "
+				"be introduced", tmpl);
+return false;
+}
+return true;
+}
+/* Associates a constraint check to the current template based on the
+introduction parameters.  INTRO_LIST must be a TREE_VEC of WILDCARD_DECLs
+containing a chained PARM_DECL which contains the identifier as well as
+the source location. TMPL_DECL is the decl for the concept being used.
+If we take a concept, C, this will form a check in the form of
+C<INTRO_LIST> filling in any extra arguments needed by the defaults
+deduced.
+Returns NULL_TREE if no concept could be matched and error_mark_node if
+an error occurred when matching.  */
+tree
+finish_template_introduction (tree tmpl_decl,
+			      tree intro_list,
+			      location_t intro_loc)
+{
+/* Build a concept check to deduce the actual parameters.  */
+tree expr = build_concept_check (tmpl_decl, intro_list, tf_none);
 if (expr == error_mark_node)
-return NULL_TREE;
+{
+error_at (intro_loc, "cannot deduce template parameters from "
+			   "introduction list");
+return error_mark_node;
+}
+if (!check_introduction_list (intro_list, expr))
+return error_mark_node;
 tree parms = deduce_concept_introduction (expr);
 if (!parms)
 return NULL_TREE;
 /* Build template parameter scope for introduction.  */
 tree parm_list = NULL_TREE;
 begin_template_parm_list ();
 int nargs = MIN (TREE_VEC_LENGTH (parms), TREE_VEC_LENGTH (intro_list));
-for (int n = 0; n < nargs; ++n)
+for (int n = 0; n < nargs; )
-parm_list = process_introduction_parm (parm_list, TREE_VEC_ELT (parms, n));
+parm_list = process_introduction_parms (parm_list, parms, n);
 parm_list = end_template_parm_list (parm_list);
+/* Update the number of arguments to reflect the number of deduced
+template parameter introductions.  */
+nargs = TREE_VEC_LENGTH (parm_list);
+/* Determine if any errors occurred during matching.  */
 for (int i = 0; i < TREE_VEC_LENGTH (parm_list); ++i)
 if (TREE_VALUE (TREE_VEC_ELT (parm_list, i)) == error_mark_node)
 {
 end_template_decl ();
 return error_mark_node;
 }
 /* Build a concept check for our constraint.  */
-tree check_args = make_tree_vec (TREE_VEC_LENGTH (parms));
+tree check_args = make_tree_vec (nargs);
 int n = 0;
 for (; n < TREE_VEC_LENGTH (parm_list); ++n)
 {
 tree parm = TREE_VEC_ELT (parm_list, n);
 TREE_VEC_ELT (check_args, n) = template_parm_to_arg (parm);
 /* If the template expects more parameters we should be able
 to use the defaults from our deduced concept.  */
 for (; n < TREE_VEC_LENGTH (parms); ++n)
 TREE_VEC_ELT (check_args, n) = TREE_VEC_ELT (parms, n);
-/* Associate the constraint. */
+/* Associate the constraint.  */
-tree check = build_concept_check (tmpl_decl, NULL_TREE, check_args);
+tree check = build_concept_check (tmpl_decl,
-tree constr = normalize_expression (check);
+				    check_args,
-TEMPLATE_PARMS_CONSTRAINTS (current_template_parms) = constr;
+				    tf_warning_or_error);
+TEMPLATE_PARMS_CONSTRAINTS (current_template_parms) = check;
 return parm_list;
 }
-/* Given the predicate constraint T from a constrained-type-specifier, extract
+/* Given the concept check T from a constrained-type-specifier, extract
 its TMPL and ARGS.  FIXME why do we need two different forms of
 constrained-type-specifier?  */
 void
 placeholder_extract_concept_and_args (tree t, tree &tmpl, tree &args)
 {
+if (concept_check_p (t))
+{
+t = unpack_concept_check (t);
+tmpl = TREE_OPERAND (t, 0);
+if (TREE_CODE (tmpl) == OVERLOAD)
+tmpl = OVL_FIRST (tmpl);
+args = TREE_OPERAND (t, 1);
+return;
+}
 if (TREE_CODE (t) == TYPE_DECL)
 {
 /* A constrained parameter.  Build a constraint check
 based on the prototype parameter and then extract the
 arguments from that.  */
 tree proto = CONSTRAINED_PARM_PROTOTYPE (t);
 tree check = finish_shorthand_constraint (proto, t);
 placeholder_extract_concept_and_args (check, tmpl, args);
 return;
 }
-if (TREE_CODE (t) == CHECK_CONSTR)
-{
-tree decl = CHECK_CONSTR_CONCEPT (t);
-tmpl = DECL_TI_TEMPLATE (decl);
-args = CHECK_CONSTR_ARGS (t);
-return;
-}
-gcc_unreachable ();
 }
 /* Returns true iff the placeholders C1 and C2 are equivalent.  C1
-and C2 can be either CHECK_CONSTR or TEMPLATE_TYPE_PARM.  */
+and C2 can be either TEMPLATE_TYPE_PARM or template-ids.  */
 bool
 equivalent_placeholder_constraints (tree c1, tree c2)
 {
 if (c1 && TREE_CODE (c1) == TEMPLATE_TYPE_PARM)
 return false;
 }
 return true;
 }
-/* Return a hash value for the placeholder PRED_CONSTR C.  */
+/* Return a hash value for the placeholder ATOMIC_CONSTR C.  */
 hashval_t
 hash_placeholder_constraint (tree c)
 {
 tree t, a;
 val = iterative_hash_template_arg (TREE_VEC_ELT (a, i), val);
 return val;
 }
-/*---------------------------------------------------------------------------
+/* Substitute through the simple requirement.  */
-Constraint substitution
----------------------------------------------------------------------------*/
+static tree
+tsubst_valid_expression_requirement (tree t, tree args, subst_info info)
-/* The following functions implement substitution rules for constraints.
+{
-Substitution without checking constraints happens only in the
+return tsubst_expr (t, args, info.complain, info.in_decl, false);
-instantiation of class templates. For example:
+}
-template<C1 T> struct S {
-void f(T) requires C2<T>;
+/* Substitute through the simple requirement.  */
-void g(T) requires T::value;
-};
+static tree
+tsubst_simple_requirement (tree t, tree args, subst_info info)
-S<int> s; // error instantiating S<int>::g(T)
+{
+tree t0 = TREE_OPERAND (t, 0);
-When we instantiate S, we substitute into its member declarations,
+tree expr = tsubst_valid_expression_requirement (t0, args, info);
-including their constraints. However, those constraints are not
+if (expr == error_mark_node)
-checked. Substituting int into C2<T> yields C2<int>, and substituting
-into T::value yields a substitution failure, making the program
-ill-formed.
-Note that we only ever substitute into the associated constraints
-of a declaration. That is, substitution is defined only for predicate
-constraints and conjunctions. */
-/* Substitute into the predicate constraints. Returns error_mark_node
-if the substitution into the expression fails. */
-tree
-tsubst_predicate_constraint (tree t, tree args,
-tsubst_flags_t complain, tree in_decl)
-{
-tree expr = PRED_CONSTR_EXPR (t);
-++processing_template_decl;
-tree result = tsubst_expr (expr, args, complain, in_decl, false);
---processing_template_decl;
-return build_nt (PRED_CONSTR, result);
-}
-/* Substitute into a check constraint. */
-tree
-tsubst_check_constraint (tree t, tree args,
-tsubst_flags_t complain, tree in_decl)
-{
-tree decl = CHECK_CONSTR_CONCEPT (t);
-tree tmpl = DECL_TI_TEMPLATE (decl);
-tree targs = CHECK_CONSTR_ARGS (t);
-/* Substitute through by building an template-id expression
-and then substituting into that. */
-tree expr = build_nt (TEMPLATE_ID_EXPR, tmpl, targs);
-++processing_template_decl;
-tree result = tsubst_expr (expr, args, complain, in_decl, false);
---processing_template_decl;
-if (result == error_mark_node)
 return error_mark_node;
+return finish_simple_requirement (EXPR_LOCATION (t), expr);
-/* Extract the results and rebuild the check constraint. */
+}
-decl = DECL_TEMPLATE_RESULT (TREE_OPERAND (result, 0));
-args = TREE_OPERAND (result, 1);
+/* Substitute through the type requirement.  */
-return build_nt (CHECK_CONSTR, decl, args);
+static tree
-}
+tsubst_type_requirement (tree t, tree args, subst_info info)
-/* Substitute into the conjunction of constraints. Returns
-error_mark_node if substitution into either operand fails. */
-tree
-tsubst_logical_operator (tree t, tree args,
-			 tsubst_flags_t complain, tree in_decl)
 {
 tree t0 = TREE_OPERAND (t, 0);
-tree r0 = tsubst_constraint (t0, args, complain, in_decl);
+tree type = tsubst (t0, args, info.complain, info.in_decl);
-if (r0 == error_mark_node)
+if (type == error_mark_node)
 return error_mark_node;
+return finish_type_requirement (EXPR_LOCATION (t), type);
+}
+/* True if TYPE can be deduced from EXPR.  */
+static bool
+type_deducible_p (tree expr, tree type, tree placeholder, tree args,
+subst_info info)
+{
+/* Make sure deduction is performed against ( EXPR ), so that
+references are preserved in the result.  */
+expr = force_paren_expr_uneval (expr);
+/* Replace the constraints with the instantiated constraints. This
+substitutes args into any template parameters in the trailing
+result type.  */
+tree saved_constr = PLACEHOLDER_TYPE_CONSTRAINTS (placeholder);
+tree subst_constr
+= tsubst_constraint (saved_constr,
+			 args,
+			 info.complain | tf_partial,
+			 info.in_decl);
+if (subst_constr == error_mark_node)
+return false;
+PLACEHOLDER_TYPE_CONSTRAINTS (placeholder) = subst_constr;
+/* Temporarily unlink the canonical type.  */
+tree saved_type = TYPE_CANONICAL (placeholder);
+TYPE_CANONICAL (placeholder) = NULL_TREE;
+tree deduced_type
+= do_auto_deduction (type,
+			 expr,
+			 placeholder,
+			 info.complain,
+			 adc_requirement);
+PLACEHOLDER_TYPE_CONSTRAINTS (placeholder) = saved_constr;
+TYPE_CANONICAL (placeholder) = saved_type;
+if (deduced_type == error_mark_node)
+return false;
+return true;
+}
+/* True if EXPR can not be converted to TYPE.  */
+static bool
+expression_convertible_p (tree expr, tree type, subst_info info)
+{
+tree conv =
+perform_direct_initialization_if_possible (type, expr, false,
+					       info.complain);
+if (conv == error_mark_node)
+return false;
+if (conv == NULL_TREE)
+{
+if (info.complain & tf_error)
+{
+location_t loc = EXPR_LOC_OR_LOC (expr, input_location);
+error_at (loc, "cannot convert %qE to %qT", expr, type);
+}
+return false;
+}
+return true;
+}
+/* Substitute through the compound requirement.  */
+static tree
+tsubst_compound_requirement (tree t, tree args, subst_info info)
+{
+tree t0 = TREE_OPERAND (t, 0);
 tree t1 = TREE_OPERAND (t, 1);
-tree r1 = tsubst_constraint (t1, args, complain, in_decl);
+tree expr = tsubst_valid_expression_requirement (t0, args, info);
-if (r1 == error_mark_node)
+if (expr == error_mark_node)
 return error_mark_node;
-return build_nt (TREE_CODE (t), r0, r1);
-}
+/* Check the noexcept condition.  */
+bool noexcept_p = COMPOUND_REQ_NOEXCEPT_P (t);
-namespace {
+if (noexcept_p && !expr_noexcept_p (expr, tf_none))
-/* Substitute ARGS into the expression constraint T.  */
-tree
-tsubst_expr_constr (tree t, tree args, tsubst_flags_t complain, tree in_decl)
-{
-cp_unevaluated guard;
-tree expr = EXPR_CONSTR_EXPR (t);
-tree ret = tsubst_expr (expr, args, complain, in_decl, false);
-if (ret == error_mark_node)
 return error_mark_node;
-return build_nt (EXPR_CONSTR, ret);
-}
+/* Substitute through the type expression, if any.  */
+tree type = tsubst (t1, args, info.complain, info.in_decl);
-/* Substitute ARGS into the type constraint T.  */
+if (type == error_mark_node)
-tree
-tsubst_type_constr (tree t, tree args, tsubst_flags_t complain, tree in_decl)
-{
-tree type = TYPE_CONSTR_TYPE (t);
-tree ret = tsubst (type, args, complain, in_decl);
-if (ret == error_mark_node)
 return error_mark_node;
-return build_nt (TYPE_CONSTR, ret);
-}
+/* Check expression against the result type.  */
+if (type)
-/* Substitute ARGS into the implicit conversion constraint T.  */
+{
+if (tree placeholder = type_uses_auto (type))
-tree
+	{
-tsubst_implicit_conversion_constr (tree t, tree args, tsubst_flags_t complain,
+	  if (!type_deducible_p (expr, type, placeholder, args, info))
-tree in_decl)
+	    return error_mark_node;
-{
+	}
-cp_unevaluated guard;
+else if (!expression_convertible_p (expr, type, info))
-tree expr = ICONV_CONSTR_EXPR (t);
+	return error_mark_node;
-tree type = ICONV_CONSTR_TYPE (t);
+}
-tree new_expr = tsubst_expr (expr, args, complain, in_decl, false);
-if (new_expr == error_mark_node)
+return finish_compound_requirement (EXPR_LOCATION (t),
+				      expr, type, noexcept_p);
+}
+static tree
+tsubst_nested_requirement (tree t, tree args, subst_info info)
+{
+gcc_assert (!uses_template_parms (args));
+/* Ensure that we're in an evaluation context prior to satisfaction.  */
+tree norm = TREE_VALUE (TREE_TYPE (t));
+tree result = satisfy_constraint (norm, args, info);
+if (result != boolean_true_node)
 return error_mark_node;
-tree new_type = tsubst (type, args, complain, in_decl);
+return result;
-if (new_type == error_mark_node)
+}
-return error_mark_node;
-return build_nt (ICONV_CONSTR, new_expr, new_type);
+/* Substitute ARGS into the requirement T.  */
-}
+static tree
-/* Substitute ARGS into the argument deduction constraint T.  */
+tsubst_requirement (tree t, tree args, subst_info info)
+{
-tree
+iloc_sentinel loc_s (cp_expr_location (t));
-tsubst_argument_deduction_constr (tree t, tree args, tsubst_flags_t complain,
+switch (TREE_CODE (t))
-tree in_decl)
+{
-{
+case SIMPLE_REQ:
-cp_unevaluated guard;
+return tsubst_simple_requirement (t, args, info);
-tree expr = DEDUCT_CONSTR_EXPR (t);
+case TYPE_REQ:
-tree pattern = DEDUCT_CONSTR_PATTERN (t);
+return tsubst_type_requirement (t, args, info);
-tree autos = DEDUCT_CONSTR_PLACEHOLDER(t);
+case COMPOUND_REQ:
-tree new_expr = tsubst_expr (expr, args, complain, in_decl, false);
+return tsubst_compound_requirement (t, args, info);
-if (new_expr == error_mark_node)
+case NESTED_REQ:
-return error_mark_node;
+return tsubst_nested_requirement (t, args, info);
-/* It seems like substituting through the pattern will not affect the
+default:
-placeholders.  We should (?) be able to reuse the existing list
+break;
-without any problems.  If not, then we probably want to create a
+}
-new list of placeholders and then instantiate the pattern using
+gcc_unreachable ();
-those.  */
+}
-tree new_pattern = tsubst (pattern, args, complain, in_decl);
-if (new_pattern == error_mark_node)
+/* Substitute ARGS into the list of requirements T. Note that
-return error_mark_node;
+substitution failures here result in ill-formed programs. */
-return build_nt (DEDUCT_CONSTR, new_expr, new_pattern, autos);
-}
+static tree
+tsubst_requirement_body (tree t, tree args, subst_info info)
-/* Substitute ARGS into the exception constraint T.  */
+{
+tree result = NULL_TREE;
-tree
+while (t)
-tsubst_exception_constr (tree t, tree args, tsubst_flags_t complain,
+{
-			 tree in_decl)
+tree req = tsubst_requirement (TREE_VALUE (t), args, info);
-{
+if (req == error_mark_node)
-cp_unevaluated guard;
+	return error_mark_node;
-tree expr = EXCEPT_CONSTR_EXPR (t);
+result = tree_cons (NULL_TREE, req, result);
-tree ret = tsubst_expr (expr, args, complain, in_decl, false);
+t = TREE_CHAIN (t);
-if (ret == error_mark_node)
+}
-return error_mark_node;
+return nreverse (result);
-return build_nt (EXCEPT_CONSTR, ret);
+}
-}
+static tree
-/* A subroutine of tsubst_constraint_variables. Register local
-specializations for each of parameter in PARMS and its
-corresponding substituted constraint variable in VARS.
-Returns VARS. */
-tree
 declare_constraint_vars (tree parms, tree vars)
 {
 tree s = vars;
 for (tree t = parms; t; t = DECL_CHAIN (t))
 {
 }
 }
 return vars;
 }
+/* Substitute through as if checking function parameter types. This
+will diagnose common parameter type errors.  Returns error_mark_node
+if an error occurred.  */
+static tree
+check_constaint_variables (tree t, tree args, subst_info info)
+{
+tree types = NULL_TREE;
+tree p = t;
+while (p && !VOID_TYPE_P (p))
+{
+types = tree_cons (NULL_TREE, TREE_TYPE (p), types);
+p = TREE_CHAIN (p);
+}
+types = chainon (nreverse (types), void_list_node);
+return tsubst_function_parms (types, args, info.complain, info.in_decl);
+}
 /* A subroutine of tsubst_parameterized_constraint. Substitute ARGS
 into the parameter list T, producing a sequence of constraint
 variables, declared in the current scope.
 Note that the caller must establish a local specialization stack
 prior to calling this function since this substitution will
 declare the substituted parameters. */
-tree
+static tree
-tsubst_constraint_variables (tree t, tree args,
+tsubst_constraint_variables (tree t, tree args, subst_info info)
-tsubst_flags_t complain, tree in_decl)
+{
-{
+/* Perform a trial substitution to check for type errors.  */
+tree parms = check_constaint_variables (t, args, info);
+if (parms == error_mark_node)
+return error_mark_node;
 /* Clear cp_unevaluated_operand across tsubst so that we get a proper chain
 of PARM_DECLs.  */
 int saved_unevaluated_operand = cp_unevaluated_operand;
 cp_unevaluated_operand = 0;
-tree vars = tsubst (t, args, complain, in_decl);
+tree vars = tsubst (t, args, info.complain, info.in_decl);
 cp_unevaluated_operand = saved_unevaluated_operand;
 if (vars == error_mark_node)
 return error_mark_node;
 return declare_constraint_vars (t, vars);
 }
-/* Substitute ARGS into the parameterized constraint T.  */
+/* Substitute ARGS into the requires-expression T. [8.4.7]p6. The
+substitution of template arguments into a requires-expression
-tree
+may result in the formation of invalid types or expressions
-tsubst_parameterized_constraint (tree t, tree args,
+in its requirements ... In such cases, the expression evaluates
-				 tsubst_flags_t complain, tree in_decl)
+to false; it does not cause the program to be ill-formed.
-{
-local_specialization_stack stack;
+However, there are cases where substitution must produce a
-tree vars = tsubst_constraint_variables (PARM_CONSTR_PARMS (t),
+new requires-expression, that is not a template constraint.
-					   args, complain, in_decl);
+For example:
-if (vars == error_mark_node)
-return error_mark_node;
+template<typename T>
-tree expr = tsubst_constraint (PARM_CONSTR_OPERAND (t), args,
+class X {
-				 complain, in_decl);
+template<typename U>
-if (expr == error_mark_node)
+static constexpr bool var = requires (U u) { T::fn(u); };
-return error_mark_node;
+};
-return build_nt (PARM_CONSTR, vars, expr);
-}
+In the instantiation of X<Y> (assuming Y defines fn), then the
+instantiated requires-expression would include Y::fn(u). If any
-/* Substitute ARGS into the simple requirement T. Note that
+substitution in the requires-expression fails, we can immediately
-substitution may result in an ill-formed expression without
+fold the expression to false, as would be the case e.g., when
-causing the program to be ill-formed. In such cases, the
+instantiation X<int>.  */
-requirement wraps an error_mark_node. */
-inline tree
-tsubst_simple_requirement (tree t, tree args,
-tsubst_flags_t complain, tree in_decl)
-{
-++processing_template_decl;
-tree expr = tsubst_expr (TREE_OPERAND (t, 0), args, complain, in_decl, false);
---processing_template_decl;
-return finish_simple_requirement (expr);
-}
-/* Substitute ARGS into the type requirement T. Note that
-substitution may result in an ill-formed type without
-causing the program to be ill-formed. In such cases, the
-requirement wraps an error_mark_node. */
-inline tree
-tsubst_type_requirement (tree t, tree args,
-tsubst_flags_t complain, tree in_decl)
-{
-++processing_template_decl;
-tree type = tsubst (TREE_OPERAND (t, 0), args, complain, in_decl);
---processing_template_decl;
-return finish_type_requirement (type);
-}
-/* Substitute args into the compound requirement T. If substituting
-into either the expression or the type fails, the corresponding
-operands in the resulting node will be error_mark_node. This
-preserves a requirement for the purpose of partial ordering, but
-it will never be satisfied. */
-tree
-tsubst_compound_requirement (tree t, tree args,
-tsubst_flags_t complain, tree in_decl)
-{
-++processing_template_decl;
-tree expr = tsubst_expr (TREE_OPERAND (t, 0), args, complain, in_decl, false);
-tree type = tsubst (TREE_OPERAND (t, 1), args, complain, in_decl);
---processing_template_decl;
-bool noexcept_p = COMPOUND_REQ_NOEXCEPT_P (t);
-return finish_compound_requirement (expr, type, noexcept_p);
-}
-/* Substitute ARGS into the nested requirement T. */
-tree
-tsubst_nested_requirement (tree t, tree args,
-tsubst_flags_t complain, tree in_decl)
-{
-++processing_template_decl;
-tree expr = tsubst_expr (TREE_OPERAND (t, 0), args, complain, in_decl, false);
---processing_template_decl;
-return finish_nested_requirement (expr);
-}
-/* Substitute ARGS into the requirement T.  */
-inline tree
-tsubst_requirement (tree t, tree args, tsubst_flags_t complain, tree in_decl)
-{
-switch (TREE_CODE (t))
-{
-case SIMPLE_REQ:
-return tsubst_simple_requirement (t, args, complain, in_decl);
-case TYPE_REQ:
-return tsubst_type_requirement (t, args, complain, in_decl);
-case COMPOUND_REQ:
-return tsubst_compound_requirement (t, args, complain, in_decl);
-case NESTED_REQ:
-return tsubst_nested_requirement (t, args, complain, in_decl);
-default:
-gcc_unreachable ();
-}
-return error_mark_node;
-}
-/* Substitute ARGS into the list of requirements T. Note that
-substitution failures here result in ill-formed programs. */
-tree
-tsubst_requirement_body (tree t, tree args,
-tsubst_flags_t complain, tree in_decl)
-{
-tree r = NULL_TREE;
-while (t)
-{
-tree e = tsubst_requirement (TREE_VALUE (t), args, complain, in_decl);
-if (e == error_mark_node)
-return error_mark_node;
-r = tree_cons (NULL_TREE, e, r);
-t = TREE_CHAIN (t);
-}
-/* Ensure that the order of constraints is the same as the original.  */
-return nreverse (r);
-}
-} /* namespace */
-/* Substitute ARGS into the requires expression T. Note that this
-results in the re-declaration of local parameters when
-substituting through the parameter list. If either substitution
-fails, the program is ill-formed. */
 tree
 tsubst_requires_expr (tree t, tree args,
-tsubst_flags_t complain, tree in_decl)
+		      tsubst_flags_t complain, tree in_decl)
 {
-local_specialization_stack stack;
+local_specialization_stack stack (lss_copy);
+subst_info info (complain, in_decl);
+/* A requires-expression is an unevaluated context.  */
+cp_unevaluated u;
 tree parms = TREE_OPERAND (t, 0);
 if (parms)
 {
-parms = tsubst_constraint_variables (parms, args, complain, in_decl);
+parms = tsubst_constraint_variables (parms, args, info);
 if (parms == error_mark_node)
-return error_mark_node;
+	return boolean_false_node;
 }
 tree reqs = TREE_OPERAND (t, 1);
-reqs = tsubst_requirement_body (reqs, args, complain, in_decl);
+reqs = tsubst_requirement_body (reqs, args, info);
 if (reqs == error_mark_node)
-return error_mark_node;
+return boolean_false_node;
-return finish_requires_expr (parms, reqs);
+/* In certain cases, produce a new requires-expression.
+Otherwise the value of the expression is true.  */
+if (processing_template_decl && uses_template_parms (args))
+return finish_requires_expr (cp_expr_location (t), parms, reqs);
+return boolean_true_node;
 }
 /* Substitute ARGS into the constraint information CI, producing a new
-constraint record. */
+constraint record.  */
 tree
 tsubst_constraint_info (tree t, tree args,
 tsubst_flags_t complain, tree in_decl)
 {
 if (!t || t == error_mark_node || !check_constraint_info (t))
 return NULL_TREE;
-tree tmpl_constr = NULL_TREE;
+tree tr = tsubst_constraint (CI_TEMPLATE_REQS (t), args, complain, in_decl);
-if (tree r = CI_TEMPLATE_REQS (t))
+tree dr = tsubst_constraint (CI_DECLARATOR_REQS (t), args, complain, in_decl);
-tmpl_constr = tsubst_constraint (r, args, complain, in_decl);
+return build_constraints (tr, dr);
+}
-tree decl_constr = NULL_TREE;
-if (tree r = CI_DECLARATOR_REQS (t))
+/* Substitute through a parameter mapping, in order to get the actual
-decl_constr = tsubst_constraint (r, args, complain, in_decl);
+arguments used to instantiate an atomic constraint.  This may fail
+if the substitution into arguments produces something ill-formed.  */
-return build_constraints (tmpl_constr, decl_constr);
-}
+static tree
+tsubst_parameter_mapping (tree map, tree args, subst_info info)
-/* Substitute ARGS into the constraint T. */
+{
+if (!map)
-tree
+return NULL_TREE;
-tsubst_constraint (tree t, tree args, tsubst_flags_t complain, tree in_decl)
-{
+tsubst_flags_t complain = info.complain;
-if (t == NULL_TREE || t == error_mark_node)
+tree in_decl = info.in_decl;
-return t;
-switch (TREE_CODE (t))
+tree result = NULL_TREE;
-{
+for (tree p = map; p; p = TREE_CHAIN (p))
-case PRED_CONSTR:
+{
-return tsubst_predicate_constraint (t, args, complain, in_decl);
+if (p == error_mark_node)
-case CHECK_CONSTR:
+return error_mark_node;
-return tsubst_check_constraint (t, args, complain, in_decl);
+tree parm = TREE_VALUE (p);
-case CONJ_CONSTR:
+tree arg = TREE_PURPOSE (p);
-case DISJ_CONSTR:
+tree new_arg = NULL_TREE;
-return tsubst_logical_operator (t, args, complain, in_decl);
+if (TYPE_P (arg))
-case PARM_CONSTR:
+{
-return tsubst_parameterized_constraint (t, args, complain, in_decl);
+/* If a template parameter is declared with a placeholder, we can
-case EXPR_CONSTR:
+get those in the argument list if decltype is applied to the
-return tsubst_expr_constr (t, args, complain, in_decl);
+placeholder. For example:
-case TYPE_CONSTR:
-return tsubst_type_constr (t, args, complain, in_decl);
+		template<auto T>
-case ICONV_CONSTR:
+		  requires C<decltype(T)>
-return tsubst_implicit_conversion_constr (t, args, complain, in_decl);
+		void f() { }
-case DEDUCT_CONSTR:
-return tsubst_argument_deduction_constr (t, args, complain, in_decl);
+	     The normalized argument for C will be an auto type, so we'll
-case EXCEPT_CONSTR:
+need to deduce the actual argument from the corresponding
-return tsubst_exception_constr (t, args, complain, in_decl);
+initializer (whatever argument is provided for T), and use
-default:
+that result in the instantiated parameter mapping.  */
-gcc_unreachable ();
+if (tree auto_node = type_uses_auto (arg))
-}
+{
-return error_mark_node;
+int level;
+int index;
+	      template_parm_level_and_index (parm, &level, &index);
+	      tree init = TMPL_ARG (args, level, index);
+new_arg = do_auto_deduction (arg, init, auto_node,
+					   complain, adc_variable_type,
+					   make_tree_vec (0));
+}
+}
+else if (ARGUMENT_PACK_P (arg))
+	new_arg = tsubst_argument_pack (arg, args, complain, in_decl);
+if (!new_arg)
+	new_arg = tsubst_template_arg (arg, args, complain, in_decl);
+if (new_arg == error_mark_node)
+	return error_mark_node;
+result = tree_cons (new_arg, parm, result);
+}
+return nreverse (result);
+}
+tree
+tsubst_parameter_mapping (tree map, tree args, tsubst_flags_t complain, tree in_decl)
+{
+return tsubst_parameter_mapping (map, args, subst_info (complain, in_decl));
 }
 /*---------------------------------------------------------------------------
 Constraint satisfaction
 ---------------------------------------------------------------------------*/
-/* The following functions determine if a constraint, when
+/* Hash functions for satisfaction entries.  */
-substituting template arguments, is satisfied. For convenience,
-satisfaction reduces a constraint to either true or false (and
+struct GTY((for_user)) sat_entry
-nothing else). */
+{
+tree constr;
-namespace {
+tree args;
+tree result;
-tree satisfy_constraint_1 (tree, tree, tsubst_flags_t, tree);
+};
-/* Check the constraint pack expansion.  */
+struct sat_hasher : ggc_ptr_hash<sat_entry>
+{
-tree
+static hashval_t hash (sat_entry *e)
-satisfy_pack_expansion (tree t, tree args,
+{
-tsubst_flags_t complain, tree in_decl)
+hashval_t value = hash_atomic_constraint (e->constr);
-{
+return iterative_hash_template_arg (e->args, value);
-/* Get the vector of satisfaction results.
+}
-gen_elem_of_pack_expansion_instantiation will check that each element of
-the expansion is satisfied.  */
+static bool equal (sat_entry *e1, sat_entry *e2)
-tree exprs = tsubst_pack_expansion (t, args, complain, in_decl);
+{
+if (!atomic_constraints_identical_p (e1->constr, e2->constr))
-if (exprs == error_mark_node)
+return false;
+return template_args_equal (e1->args, e2->args);
+}
+};
+/* Cache the result of satisfy_atom.  */
+static GTY((deletable)) hash_table<sat_hasher> *sat_cache;
+/* Cache the result of constraint_satisfaction_value.  */
+static GTY((deletable)) hash_map<tree, tree> *decl_satisfied_cache;
+static tree
+get_satisfaction (tree constr, tree args)
+{
+if (!sat_cache)
+return NULL_TREE;
+sat_entry elt = { constr, args, NULL_TREE };
+sat_entry* found = sat_cache->find (&elt);
+if (found)
+return found->result;
+else
+return NULL_TREE;
+}
+static void
+save_satisfaction (tree constr, tree args, tree result)
+{
+if (!sat_cache)
+sat_cache = hash_table<sat_hasher>::create_ggc (31);
+sat_entry elt = {constr, args, result};
+sat_entry** slot = sat_cache->find_slot (&elt, INSERT);
+sat_entry* entry = ggc_alloc<sat_entry> ();
+*entry = elt;
+*slot = entry;
+}
+void
+clear_satisfaction_cache ()
+{
+if (sat_cache)
+sat_cache->empty ();
+if (decl_satisfied_cache)
+decl_satisfied_cache->empty ();
+}
+/* A tool to help manage satisfaction caching in satisfy_constraint_r.
+Note the cache is only used when not diagnosing errors.  */
+struct satisfaction_cache
+{
+satisfaction_cache (tree constr, tree args, tsubst_flags_t complain)
+: constr(constr), args(args), complain(complain)
+{ }
+tree get ()
+{
+if (complain == tf_none)
+return get_satisfaction (constr, args);
+return NULL_TREE;
+}
+tree save (tree result)
+{
+if (complain == tf_none)
+save_satisfaction (constr, args, result);
+return result;
+}
+tree constr;
+tree args;
+tsubst_flags_t complain;
+};
+static int satisfying_constraint = 0;
+/* Returns true if we are currently satisfying a constraint.
+This is used to guard against recursive calls to evaluate_concept_check
+during template argument substitution.
+TODO: Do we need this now that we fully normalize prior to evaluation?
+I think not. */
+bool
+satisfying_constraint_p ()
+{
+return satisfying_constraint;
+}
+/* Substitute ARGS into constraint-expression T during instantiation of
+a member of a class template.  */
+tree
+tsubst_constraint (tree t, tree args, tsubst_flags_t complain, tree in_decl)
+{
+/* We also don't want to evaluate concept-checks when substituting the
+constraint-expressions of a declaration.  */
+processing_constraint_expression_sentinel s;
+tree expr = tsubst_expr (t, args, complain, in_decl, false);
+return expr;
+}
+static tree satisfy_constraint_r (tree, tree, subst_info info);
+/* Compute the satisfaction of a conjunction.  */
+static tree
+satisfy_conjunction (tree t, tree args, subst_info info)
+{
+tree lhs = satisfy_constraint_r (TREE_OPERAND (t, 0), args, info);
+if (lhs == error_mark_node || lhs == boolean_false_node)
+return lhs;
+return satisfy_constraint_r (TREE_OPERAND (t, 1), args, info);
+}
+/* Compute the satisfaction of a disjunction.  */
+static tree
+satisfy_disjunction (tree t, tree args, subst_info info)
+{
+/* Evaluate the operands quietly.  */
+subst_info quiet (tf_none, NULL_TREE);
+/* Register the constraint for diagnostics, if needed.  */
+diagnosing_failed_constraint failure (t, args, info.noisy ());
+tree lhs = satisfy_constraint_r (TREE_OPERAND (t, 0), args, quiet);
+if (lhs == boolean_true_node)
+return boolean_true_node;
+tree rhs = satisfy_constraint_r (TREE_OPERAND (t, 1), args, quiet);
+if (rhs != boolean_true_node && info.noisy ())
+{
+location_t loc = cp_expr_location (CONSTR_EXPR (t));
+inform (loc, "neither operand of the disjunction is satisfied");
+/* TODO: Replay the LHS and RHS to find failures in both branches.  */
+// satisfy_constraint_r (TREE_OPERAND (t, 0), args, info);
+// satisfy_constraint_r (TREE_OPERAND (t, 1), args, info);
+}
+return rhs;
+}
+/* Ensures that T is a truth value and not (accidentally, as sometimes
+happens) an integer value.  */
+tree
+satisfaction_value (tree t)
+{
+if (t == error_mark_node)
+return t;
+if (t == boolean_true_node || t == integer_one_node)
+return boolean_true_node;
+if (t == boolean_false_node || t == integer_zero_node)
 return boolean_false_node;
-/* TODO: It might be better to normalize each expanded term
+/* Anything else should be invalid.  */
-and evaluate them separately. That would provide better
+gcc_assert (false);
-opportunities for diagnostics.  */
+}
-for (int i = 0; i < TREE_VEC_LENGTH (exprs); ++i)
-if (TREE_VEC_ELT (exprs, i) != boolean_true_node)
+/* Build a new template argument list with template arguments corresponding
-return boolean_false_node;
+to the parameters used in an atomic constraint.  */
-return boolean_true_node;
-}
+tree
+get_mapped_args (tree map)
-/* A predicate constraint is satisfied if its expression evaluates
+{
-to true. If substitution into that node fails, the constraint
+/* No map, no arguments.  */
-is not satisfied ([temp.constr.pred]).
+if (!map)
+return NULL_TREE;
-Note that a predicate constraint is a constraint expression
-of type bool. If neither of those are true, the program is
+/* Find the mapped parameter with the highest level.  */
-ill-formed; they are not SFINAE'able errors. */
+int count = 0;
+for (tree p = map; p; p = TREE_CHAIN (p))
-tree
+{
-satisfy_predicate_constraint (tree t, tree args,
+int level;
-tsubst_flags_t complain, tree in_decl)
+int index;
-{
+template_parm_level_and_index (TREE_VALUE (p), &level, &index);
-tree expr = TREE_OPERAND (t, 0);
+if (level > count)
+count = level;
-/* We should never have a naked pack expansion in a predicate constraint.  */
+}
-gcc_assert (TREE_CODE (expr) != EXPR_PACK_EXPANSION);
+/* Place each argument at its corresponding position in the argument
-/* If substitution into the expression fails, the constraint
+list. Note that the list will be sparse (not all arguments supplied),
-is not satisfied.  */
+but instantiation is guaranteed to only use the parameters in the
-expr = tsubst_expr (expr, args, complain, in_decl, false);
+mapping, so null arguments would never be used.  */
-if (expr == error_mark_node)
+auto_vec< vec<tree> > lists (count);
-return boolean_false_node;
+lists.quick_grow_cleared (count);
+for (tree p = map; p; p = TREE_CHAIN (p))
-/* A predicate constraint shall have type bool. In some
+{
-cases, substitution gives us const-qualified bool, which
+int level;
-is also acceptable.  */
+int index;
-tree type = cv_unqualified (TREE_TYPE (expr));
+template_parm_level_and_index (TREE_VALUE (p), &level, &index);
-if (!same_type_p (type, boolean_type_node))
-{
+/* Insert the argument into its corresponding position.  */
-error_at (cp_expr_loc_or_loc (expr, input_location),
+vec<tree> &list = lists[level - 1];
-"constraint %qE does not have type %qT",
+if (index >= (int)list.length ())
-expr, boolean_type_node);
+	list.safe_grow_cleared (index + 1);
-return boolean_false_node;
+list[index] = TREE_PURPOSE (p);
 }
-return cxx_constant_value (expr);
+/* Build the new argument list.  */
-}
+tree args = make_tree_vec (lists.length ());
+for (unsigned i = 0; i != lists.length (); ++i)
-/* A concept check constraint like C<CARGS> is satisfied if substituting ARGS
+{
-into CARGS succeeds and C is satisfied for the resulting arguments.  */
+vec<tree> &list = lists[i];
+tree level = make_tree_vec (list.length ());
-tree
+for (unsigned j = 0; j < list.length(); ++j)
-satisfy_check_constraint (tree t, tree args,
+	TREE_VEC_ELT (level, j) = list[j];
-tsubst_flags_t complain, tree in_decl)
+SET_TMPL_ARGS_LEVEL (args, i + 1, level);
-{
+list.release ();
-tree decl = CHECK_CONSTR_CONCEPT (t);
+}
-tree tmpl = DECL_TI_TEMPLATE (decl);
+SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (args, 0);
-tree cargs = CHECK_CONSTR_ARGS (t);
+return args;
-/* Instantiate the concept check arguments.  */
+}
-tree targs = tsubst (cargs, args, tf_none, NULL_TREE);
-if (targs == error_mark_node)
+static void diagnose_atomic_constraint (tree, tree, subst_info);
-return boolean_false_node;
+/* Compute the satisfaction of an atomic constraint.  */
-/* Search for a previous value.  */
-if (tree prev = lookup_concept_satisfaction (tmpl, targs))
+static tree
-return prev;
+satisfy_atom (tree t, tree args, subst_info info)
+{
-/* Expand the concept; failure here implies non-satisfaction.  */
+satisfaction_cache cache (t, args, info.complain);
-tree def = expand_concept (decl, targs);
+if (tree r = cache.get ())
-if (def == error_mark_node)
+return r;
-return memoize_concept_satisfaction (tmpl, args, boolean_false_node);
+/* Perform substitution quietly.  */
-/* Recursively satisfy the constraint.  */
+subst_info quiet (tf_none, NULL_TREE);
-tree result = satisfy_constraint_1 (def, targs, complain, in_decl);
-return memoize_concept_satisfaction (tmpl, targs, result);
+/* In case there is a diagnostic, we want to establish the context
-}
+prior to printing errors.  If no errors occur, this context is
+removed before returning.  */
-/* Check an expression constraint. The constraint is satisfied if
+diagnosing_failed_constraint failure (t, args, info.noisy ());
-substitution succeeds ([temp.constr.expr]).
+/* Instantiate the parameter mapping.  */
-Note that the expression is unevaluated. */
+tree map = tsubst_parameter_mapping (ATOMIC_CONSTR_MAP (t), args, quiet);
+if (map == error_mark_node)
-tree
+{
-satisfy_expression_constraint (tree t, tree args,
+/* If instantiation of the parameter mapping fails, the program
-tsubst_flags_t complain, tree in_decl)
+is ill-formed.  */
-{
+if (info.noisy())
-cp_unevaluated guard;
+	tsubst_parameter_mapping (ATOMIC_CONSTR_MAP (t), args, info);
-deferring_access_check_sentinel deferring;
+return cache.save (boolean_false_node);
+}
-tree expr = EXPR_CONSTR_EXPR (t);
-tree check = tsubst_expr (expr, args, complain, in_decl, false);
+/* Rebuild the argument vector from the parameter mapping.  */
-if (check == error_mark_node)
+args = get_mapped_args (map);
-return boolean_false_node;
-if (!perform_deferred_access_checks (tf_none))
+/* Apply the parameter mapping (i.e., just substitute).  */
-return boolean_false_node;
+tree expr = ATOMIC_CONSTR_EXPR (t);
-return boolean_true_node;
+tree result = tsubst_expr (expr, args, quiet.complain, quiet.in_decl, false);
-}
+if (result == error_mark_node)
+{
-/* Check a type constraint. The constraint is satisfied if
+/* If substitution results in an invalid type or expression, the constraint
-substitution succeeds. */
+	 is not satisfied. Replay the substitution.  */
+if (info.noisy ())
-inline tree
+	tsubst_expr (expr, args, info.complain, info.in_decl, false);
-satisfy_type_constraint (tree t, tree args,
+return cache.save (boolean_false_node);
-tsubst_flags_t complain, tree in_decl)
+}
-{
-deferring_access_check_sentinel deferring;
+location_t loc = cp_expr_loc_or_input_loc (expr);
-tree type = TYPE_CONSTR_TYPE (t);
-gcc_assert (TYPE_P (type) || type == error_mark_node);
+/* [17.4.1.2] ... lvalue-to-value conversion is performed as necessary,
-tree check = tsubst (type, args, complain, in_decl);
+and EXPR shall be a constant expression of type bool.  */
-if (error_operand_p (check))
+result = force_rvalue (result, info.complain);
-return boolean_false_node;
+if (result == error_mark_node)
-if (!perform_deferred_access_checks (complain))
+return cache.save (error_mark_node);
-return boolean_false_node;
+if (!same_type_p (TREE_TYPE (result), boolean_type_node))
-return boolean_true_node;
+{
-}
+if (info.noisy ())
+	error_at (loc, "constraint does not have type %<bool%>");
-/* Check an implicit conversion constraint.  */
+return cache.save (error_mark_node);
+}
-tree
-satisfy_implicit_conversion_constraint (tree t, tree args,
+/* Compute the value of the constraint.  */
-tsubst_flags_t complain, tree in_decl)
+result = satisfaction_value (cxx_constant_value (result));
-{
+if (result == boolean_false_node && info.noisy ())
-/* Don't tsubst as if we're processing a template. If we try
+diagnose_atomic_constraint (t, args, info);
-to we can end up generating template-like expressions
-(e.g., modop-exprs) that aren't properly typed.  */
+return cache.save (result);
-tree expr =
+}
-tsubst_expr (ICONV_CONSTR_EXPR (t), args, complain, in_decl, false);
-if (expr == error_mark_node)
+/* Determine if the normalized constraint T is satisfied.
-return boolean_false_node;
+Returns boolean_true_node if the expression/constraint is
+satisfied, boolean_false_node if not, and error_mark_node
-/* Get the transformed target type.  */
+if the there was an error evaluating the constraint.
-tree type = tsubst (ICONV_CONSTR_TYPE (t), args, complain, in_decl);
-if (type == error_mark_node)
+The parameter mapping of atomic constraints is simply the
-return boolean_false_node;
+set of template arguments that will be substituted into
+the expression, regardless of template parameters appearing
-/* Attempt the conversion as a direct initialization
+withing. Whether a template argument is used in the atomic
-of the form TYPE <unspecified> = EXPR.  */
+constraint only matters for subsumption.  */
-tree conv =
-perform_direct_initialization_if_possible (type, expr, false, complain);
+static tree
-if (conv == NULL_TREE || conv == error_mark_node)
+satisfy_constraint_r (tree t, tree args, subst_info info)
-return boolean_false_node;
+{
-else
-return boolean_true_node;
-}
-/* Check an argument deduction constraint. */
-tree
-satisfy_argument_deduction_constraint (tree t, tree args,
-tsubst_flags_t complain, tree in_decl)
-{
-/* Substitute through the expression. */
-tree expr = DEDUCT_CONSTR_EXPR (t);
-tree init = tsubst_expr (expr, args, complain, in_decl, false);
-if (expr == error_mark_node)
-return boolean_false_node;
-/* Perform auto or decltype(auto) deduction to get the result. */
-tree pattern = DEDUCT_CONSTR_PATTERN (t);
-tree placeholder = DEDUCT_CONSTR_PLACEHOLDER (t);
-tree constr = PLACEHOLDER_TYPE_CONSTRAINTS (placeholder);
-tree type_canonical = TYPE_CANONICAL (placeholder);
-PLACEHOLDER_TYPE_CONSTRAINTS (placeholder)
-= tsubst_constraint (constr, args, complain|tf_partial, in_decl);
-TYPE_CANONICAL (placeholder) = NULL_TREE;
-tree type = do_auto_deduction (pattern, init, placeholder,
-complain, adc_requirement);
-PLACEHOLDER_TYPE_CONSTRAINTS (placeholder) = constr;
-TYPE_CANONICAL (placeholder) = type_canonical;
-if (type == error_mark_node)
-return boolean_false_node;
-return boolean_true_node;
-}
-/* Check an exception constraint. An exception constraint for an
-expression e is satisfied when noexcept(e) is true. */
-tree
-satisfy_exception_constraint (tree t, tree args,
-tsubst_flags_t complain, tree in_decl)
-{
-tree expr = EXCEPT_CONSTR_EXPR (t);
-tree check = tsubst_expr (expr, args, complain, in_decl, false);
-if (check == error_mark_node)
-return boolean_false_node;
-if (expr_noexcept_p (check, complain))
-return boolean_true_node;
-else
-return boolean_false_node;
-}
-/* Check a parameterized constraint. */
-tree
-satisfy_parameterized_constraint (tree t, tree args,
-tsubst_flags_t complain, tree in_decl)
-{
-local_specialization_stack stack;
-tree parms = PARM_CONSTR_PARMS (t);
-tree vars = tsubst_constraint_variables (parms, args, complain, in_decl);
-if (vars == error_mark_node)
-return boolean_false_node;
-tree constr = PARM_CONSTR_OPERAND (t);
-return satisfy_constraint_1 (constr, args, complain, in_decl);
-}
-/* Check that the conjunction of constraints is satisfied. Note
-that if left operand is not satisfied, the right operand
-is not checked.
-FIXME: Check that this wouldn't result in a user-defined
-operator. Note that this error is partially diagnosed in
-satisfy_predicate_constraint. It would be nice to diagnose
-the overload, but I don't think it's strictly necessary.  */
-tree
-satisfy_conjunction (tree t, tree args, tsubst_flags_t complain, tree in_decl)
-{
-tree t0 = satisfy_constraint_1 (TREE_OPERAND (t, 0), args, complain, in_decl);
-if (t0 == boolean_false_node)
-return boolean_false_node;
-return satisfy_constraint_1 (TREE_OPERAND (t, 1), args, complain, in_decl);
-}
-/* Check that the disjunction of constraints is satisfied. Note
-that if the left operand is satisfied, the right operand is not
-checked.  */
-tree
-satisfy_disjunction (tree t, tree args, tsubst_flags_t complain, tree in_decl)
-{
-tree t0 = satisfy_constraint_1 (TREE_OPERAND (t, 0), args, complain, in_decl);
-if (t0 == boolean_true_node)
-return boolean_true_node;
-return satisfy_constraint_1 (TREE_OPERAND (t, 1), args, complain, in_decl);
-}
-/* Dispatch to an appropriate satisfaction routine depending on the
-tree code of T.  */
-tree
-satisfy_constraint_1 (tree t, tree args, tsubst_flags_t complain, tree in_decl)
-{
-gcc_assert (!processing_template_decl);
-if (!t)
-return boolean_false_node;
 if (t == error_mark_node)
-return boolean_false_node;
+return error_mark_node;
 switch (TREE_CODE (t))
 {
-case PRED_CONSTR:
+case CONJ_CONSTR:
-return satisfy_predicate_constraint (t, args, complain, in_decl);
+return satisfy_conjunction (t, args, info);
+case DISJ_CONSTR:
-case CHECK_CONSTR:
+return satisfy_disjunction (t, args, info);
-return satisfy_check_constraint (t, args, complain, in_decl);
+case ATOMIC_CONSTR:
+return satisfy_atom (t, args, info);
-case EXPR_CONSTR:
+default:
-return satisfy_expression_constraint (t, args, complain, in_decl);
+gcc_unreachable ();
+}
-case TYPE_CONSTR:
+}
-return satisfy_type_constraint (t, args, complain, in_decl);
+/* Check that the normalized constraint T is satisfied for ARGS.  */
-case ICONV_CONSTR:
-return satisfy_implicit_conversion_constraint (t, args, complain, in_decl);
+static tree
+satisfy_constraint (tree t, tree args, subst_info info)
-case DEDUCT_CONSTR:
-return satisfy_argument_deduction_constraint (t, args, complain, in_decl);
-case EXCEPT_CONSTR:
-return satisfy_exception_constraint (t, args, complain, in_decl);
-case PARM_CONSTR:
-return satisfy_parameterized_constraint (t, args, complain, in_decl);
-case CONJ_CONSTR:
-return satisfy_conjunction (t, args, complain, in_decl);
-case DISJ_CONSTR:
-return satisfy_disjunction (t, args, complain, in_decl);
-case EXPR_PACK_EXPANSION:
-return satisfy_pack_expansion (t, args, complain, in_decl);
-default:
-gcc_unreachable ();
-}
-return boolean_false_node;
-}
-/* Check that the constraint is satisfied, according to the rules
-for that constraint. Note that each satisfy_* function returns
-true or false, depending on whether it is satisfied or not.  */
-tree
-satisfy_constraint (tree t, tree args)
 {
 auto_timevar time (TV_CONSTRAINT_SAT);
 /* Turn off template processing. Constraint satisfaction only applies
 to non-dependent terms, so we want to ensure full checking here.  */
 processing_template_decl_sentinel proc (true);
-/* Avoid early exit in tsubst and tsubst_copy from null args; since earlier
+/* We need to check access during satisfaction.  */
-substitution was done with processing_template_decl forced on, there will
+deferring_access_check_sentinel acs (dk_no_deferred);
-be expressions that still need semantic processing, possibly buried in
-decltype or a template argument.  */
+return satisfy_constraint_r (t, args, info);
-if (args == NULL_TREE)
+}
-args = make_tree_vec (1);
+/* Check the normalized constraints T against ARGS, returning a satisfaction
-return satisfy_constraint_1 (t, args, tf_none, NULL_TREE);
+value (either true, false, or error).  */
-}
+static tree
-/* Check the associated constraints in CI against the given
+satisfy_associated_constraints (tree t, tree args, subst_info info)
-ARGS, returning true when the constraints are satisfied
+{
-and false otherwise.  */
+/* If there are no constraints then this is trivially satisfied.  */
+if (!t)
-tree
-satisfy_associated_constraints (tree ci, tree args)
-{
-/* If there are no constraints then this is trivially satisfied. */
-if (!ci)
 return boolean_true_node;
 /* If any arguments depend on template parameters, we can't
-check constraints. */
+check constraints. Pretend they're satisfied for now.  */
 if (args && uses_template_parms (args))
 return boolean_true_node;
-/* Check if we've seen a previous result. */
+return satisfy_constraint (t, args, info);
-if (tree prev = lookup_constraint_satisfaction (ci, args))
+}
-return prev;
+/* Evaluate EXPR as a constraint expression using ARGS, returning a
-/* Actually test for satisfaction. */
+satisfaction value. */
-tree result = satisfy_constraint (CI_ASSOCIATED_CONSTRAINTS (ci), args);
-return memoize_constraint_satisfaction (ci, args, result);
+static tree
-}
+satisfy_constraint_expression (tree t, tree args, subst_info info)
+{
-} /* namespace */
+if (t == error_mark_node)
+return error_mark_node;
-/* Evaluate the given constraint, returning boolean_true_node
-if the constraint is satisfied and boolean_false_node
+gcc_assert (EXPR_P (t));
-otherwise. */
+/* Get the normalized constraints.  */
-tree
+tree norm;
-evaluate_constraints (tree constr, tree args)
+if (args == NULL_TREE && concept_check_p (t))
 {
-gcc_assert (constraint_p (constr));
+tree id = unpack_concept_check (t);
-return satisfy_constraint (constr, args);
+args = TREE_OPERAND (id, 1);
-}
+tree tmpl = get_concept_check_template (id);
+norm = normalize_concept_definition (tmpl, info.noisy ());
-/* Evaluate the function concept FN by substituting its own args
+}
-into its definition and evaluating that as the result. Returns
+else
-boolean_true_node if the constraints are satisfied and
+norm = normalize_constraint_expression (t, info.noisy ());
-boolean_false_node otherwise.  */
+/* Perform satisfaction.  */
-tree
+return satisfy_constraint (norm, args, info);
-evaluate_function_concept (tree fn, tree args)
+}
-{
-tree constr = build_nt (CHECK_CONSTR, fn, args);
+/* Used only to evaluate requires-expressions during constant expression
-return satisfy_constraint (constr, args);
+evaluation.  */
-}
+tree
-/* Evaluate the variable concept VAR by substituting its own args into
+satisfy_constraint_expression (tree expr)
-its initializer and checking the resulting constraint. Returns
+{
-boolean_true_node if the constraints are satisfied and
+subst_info info (tf_none, NULL_TREE);
-boolean_false_node otherwise.  */
+return satisfy_constraint_expression (expr, NULL_TREE, info);
+}
-tree
-evaluate_variable_concept (tree var, tree args)
+static tree
-{
+satisfy_declaration_constraints (tree t, subst_info info)
-tree constr = build_nt (CHECK_CONSTR, var, args);
+{
-return satisfy_constraint (constr, args);
+gcc_assert (DECL_P (t));
-}
+/* For inherited constructors, consider the original declaration;
-/* Evaluate the given expression as if it were a predicate
+it has the correct template information attached. */
-constraint. Returns boolean_true_node if the constraint
+if (flag_new_inheriting_ctors)
-is satisfied and boolean_false_node otherwise. */
+t = strip_inheriting_ctors (t);
-tree
+/* Update the declaration for diagnostics.  */
-evaluate_constraint_expression (tree expr, tree args)
+info.in_decl = t;
-{
-tree constr = normalize_expression (expr);
+if (info.quiet ())
-return satisfy_constraint (constr, args);
+if (tree *result = hash_map_safe_get (decl_satisfied_cache, t))
-}
+return *result;
-/* Returns true if the DECL's constraints are satisfied.
+/* Get the normalized constraints.  */
-This is used in cases where a declaration is formed but
+tree norm = NULL_TREE;
-before it is used (e.g., overload resolution). */
+tree args = NULL_TREE;
+if (tree ti = DECL_TEMPLATE_INFO (t))
+{
+tree tmpl = TI_TEMPLATE (ti);
+norm = normalize_template_requirements (tmpl, info.noisy ());
+/* The initial parameter mapping is the complete set of
+	 template arguments substituted into the declaration.  */
+args = TI_ARGS (ti);
+}
+else
+{
+/* These should be empty until we allow constraints on non-templates.  */
+norm = normalize_nontemplate_requirements (t, info.noisy ());
+}
+tree result = boolean_true_node;
+if (norm)
+{
+if (!push_tinst_level (t))
+	return result;
+push_access_scope (t);
+result = satisfy_associated_constraints (norm, args, info);
+pop_access_scope (t);
+pop_tinst_level ();
+}
+if (info.quiet ())
+hash_map_safe_put<hm_ggc> (decl_satisfied_cache, t, result);
+return result;
+}
+static tree
+satisfy_declaration_constraints (tree t, tree args, subst_info info)
+{
+/* Update the declaration for diagnostics.  */
+info.in_decl = t;
+gcc_assert (TREE_CODE (t) == TEMPLATE_DECL);
+if (tree norm = normalize_template_requirements (t, info.noisy ()))
+{
+tree pattern = DECL_TEMPLATE_RESULT (t);
+push_access_scope (pattern);
+tree result = satisfy_associated_constraints (norm, args, info);
+pop_access_scope (pattern);
+return result;
+}
+return boolean_true_node;
+}
+static tree
+constraint_satisfaction_value (tree t, tsubst_flags_t complain)
+{
+subst_info info (complain, NULL_TREE);
+if (DECL_P (t))
+return satisfy_declaration_constraints (t, info);
+else
+return satisfy_constraint_expression (t, NULL_TREE, info);
+}
+static tree
+constraint_satisfaction_value (tree t, tree args, tsubst_flags_t complain)
+{
+subst_info info (complain, NULL_TREE);
+if (DECL_P (t))
+return satisfy_declaration_constraints (t, args, info);
+else
+return satisfy_constraint_expression (t, args, info);
+}
+/* True iff the result of satisfying T is BOOLEAN_TRUE_NODE and false
+otherwise, even in the case of errors.  */
 bool
-constraints_satisfied_p (tree decl)
+constraints_satisfied_p (tree t)
 {
-/* Get the constraints to check for satisfaction. This depends
+return constraint_satisfaction_value (t, tf_none) == boolean_true_node;
-on whether we're looking at a template specialization or not. */
+}
-tree ci;
-tree args = NULL_TREE;
+/* True iff the result of satisfying T with ARGS is BOOLEAN_TRUE_NODE
-if (tree ti = DECL_TEMPLATE_INFO (decl))
+and false otherwise, even in the case of errors.  */
-{
-tree tmpl = TI_TEMPLATE (ti);
-ci = get_constraints (tmpl);
-int depth = TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl));
-args = get_innermost_template_args (TI_ARGS (ti), depth);
-}
-else
-{
-ci = get_constraints (decl);
-}
-tree eval = satisfy_associated_constraints (ci, args);
-return eval == boolean_true_node;
-}
-/* Returns true if the constraints are satisfied by ARGS.
-Here, T can be either a constraint or a constrained
-declaration.  */
 bool
 constraints_satisfied_p (tree t, tree args)
 {
-tree eval;
+return constraint_satisfaction_value (t, args, tf_none) == boolean_true_node;
-if (constraint_p (t))
+}
-eval = evaluate_constraints (t, args);
-else
+/* Evaluate a concept check of the form C<ARGS>. This is only used for the
-eval = satisfy_associated_constraints (get_constraints (t), args);
+evaluation of template-ids as id-expressions.  */
-return eval == boolean_true_node;
-}
+tree
+evaluate_concept_check (tree check, tsubst_flags_t complain)
-namespace
+{
-{
+if (check == error_mark_node)
+return error_mark_node;
-/* Normalize EXPR and determine if the resulting constraint is
-satisfied by ARGS. Returns true if and only if the constraint
+gcc_assert (concept_check_p (check));
-is satisfied.  This is used extensively by diagnostics to
-determine causes for failure.  */
+/* Check for satisfaction without diagnostics.  */
+subst_info quiet (tf_none, NULL_TREE);
-inline bool
+tree result = satisfy_constraint_expression (check, NULL_TREE, quiet);
-constraint_expression_satisfied_p (tree expr, tree args)
+if (result == error_mark_node && (complain & tf_error))
 {
-return evaluate_constraint_expression (expr, args) == boolean_true_node;
+/* Replay the error with re-normalized requirements.  */
-}
+subst_info noisy (tf_warning_or_error, NULL_TREE);
+satisfy_constraint_expression (check, NULL_TREE, noisy);
-} /* namespace */
+}
+return result;
+}
 /*---------------------------------------------------------------------------
 Semantic analysis of requires-expressions
 ---------------------------------------------------------------------------*/
 /* Finish a requires expression for the given PARMS (possibly
-null) and the non-empty sequence of requirements. */
+null) and the non-empty sequence of requirements.  */
-tree
-finish_requires_expr (tree parms, tree reqs)
+tree
+finish_requires_expr (location_t loc, tree parms, tree reqs)
 {
 /* Modify the declared parameters by removing their context
 so they don't refer to the enclosing scope and explicitly
 indicating that they are constraint variables. */
 for (tree parm = parms; parm; parm = DECL_CHAIN (parm))
 /* Build the node. */
 tree r = build_min (REQUIRES_EXPR, boolean_type_node, parms, reqs);
 TREE_SIDE_EFFECTS (r) = false;
 TREE_CONSTANT (r) = true;
+SET_EXPR_LOCATION (r, loc);
 return r;
 }
-/* Construct a requirement for the validity of EXPR. */
+/* Construct a requirement for the validity of EXPR.   */
-tree
-finish_simple_requirement (tree expr)
+tree
-{
+finish_simple_requirement (location_t loc, tree expr)
-return build_nt (SIMPLE_REQ, expr);
+{
-}
+tree r = build_nt (SIMPLE_REQ, expr);
+SET_EXPR_LOCATION (r, loc);
-/* Construct a requirement for the validity of TYPE. */
+return r;
-tree
+}
-finish_type_requirement (tree type)
-{
+/* Construct a requirement for the validity of TYPE.  */
-return build_nt (TYPE_REQ, type);
+tree
+finish_type_requirement (location_t loc, tree type)
+{
+tree r = build_nt (TYPE_REQ, type);
+SET_EXPR_LOCATION (r, loc);
+return r;
 }
 /* Construct a requirement for the validity of EXPR, along with
 its properties. if TYPE is non-null, then it specifies either
 an implicit conversion or argument deduction constraint,
 depending on whether any placeholders occur in the type name.
-NOEXCEPT_P is true iff the noexcept keyword was specified. */
+NOEXCEPT_P is true iff the noexcept keyword was specified.  */
-tree
-finish_compound_requirement (tree expr, tree type, bool noexcept_p)
+tree
+finish_compound_requirement (location_t loc, tree expr, tree type, bool noexcept_p)
 {
 tree req = build_nt (COMPOUND_REQ, expr, type);
+SET_EXPR_LOCATION (req, loc);
 COMPOUND_REQ_NOEXCEPT_P (req) = noexcept_p;
 return req;
 }
-/* Finish a nested requirement. */
+/* Finish a nested requirement.  */
-tree
-finish_nested_requirement (tree expr)
+tree
-{
+finish_nested_requirement (location_t loc, tree expr)
-return build_nt (NESTED_REQ, expr);
+{
-}
+/* Save the normalized constraint and complete set of normalization
+arguments with the requirement.  We keep the complete set of arguments
-// Check that FN satisfies the structural requirements of a
+around for re-normalization during diagnostics.  */
-// function concept definition.
+tree args = current_template_parms
+? template_parms_to_args (current_template_parms) : NULL_TREE;
+tree norm = normalize_constraint_expression (expr, args, false);
+tree info = build_tree_list (args, norm);
+/* Build the constraint, saving its normalization as its type.  */
+tree r = build1 (NESTED_REQ, info, expr);
+SET_EXPR_LOCATION (r, loc);
+return r;
+}
+/* Check that FN satisfies the structural requirements of a
+function concept definition.  */
 tree
 check_function_concept (tree fn)
 {
-// Check that the function is comprised of only a single
+/* Check that the function is comprised of only a return statement.  */
-// return statement.
 tree body = DECL_SAVED_TREE (fn);
 if (TREE_CODE (body) == BIND_EXPR)
 body = BIND_EXPR_BODY (body);
-// Sometimes a function call results in the creation of clean up
+/* Sometimes a function call results in the creation of clean up
-// points. Allow these to be preserved in the body of the
+points. Allow these to be preserved in the body of the
-// constraint, as we might actually need them for some constexpr
+constraint, as we might actually need them for some constexpr
-// evaluations.
+evaluations.  */
 if (TREE_CODE (body) == CLEANUP_POINT_EXPR)
 body = TREE_OPERAND (body, 0);
-/* Check that the definition is written correctly. */
+/* Check that the definition is written correctly.  */
 if (TREE_CODE (body) != RETURN_EXPR)
 {
 location_t loc = DECL_SOURCE_LOCATION (fn);
 if (TREE_CODE (body) == STATEMENT_LIST && !STATEMENT_LIST_HEAD (body))
 	{
 gcc_assert (!a || TREE_CODE (a) == CONSTRAINT_INFO);
 gcc_assert (!b || TREE_CODE (b) == CONSTRAINT_INFO);
 return subsumes (a, b);
 }
-/* Returns true when the the constraints in A subsume those in B, but
+/* Returns true when the the constraints in CI (with arguments
-the constraints in B do not subsume the constraints in A.  */
+ARGS) strictly subsume the associated constraints of TMPL.  */
 bool
-strictly_subsumes (tree a, tree b)
+strictly_subsumes (tree ci, tree args, tree tmpl)
 {
-return subsumes (a, b) && !subsumes (b, a);
+tree n1 = get_normalized_constraints_from_info (ci, args, NULL_TREE);
+tree n2 = get_normalized_constraints_from_decl (tmpl);
+return subsumes (n1, n2) && !subsumes (n2, n1);
+}
+/* REturns true when the constraints in CI (with arguments ARGS) subsume
+the associated constraints of TMPL.  */
+bool
+weakly_subsumes (tree ci, tree args, tree tmpl)
+{
+tree n1 = get_normalized_constraints_from_info (ci, args, NULL_TREE);
+tree n2 = get_normalized_constraints_from_decl (tmpl);
+return subsumes (n1, n2);
 }
 /* Determines which of the declarations, A or B, is more constrained.
 That is, which declaration's constraints subsume but are not subsumed
 by the other's?
-Returns 1 if A is more constrained than B, -1 if B is more constrained
+Returns 1 if D1 is more constrained than D2, -1 if D2 is more constrained
-than A, and 0 otherwise. */
+than D1, and 0 otherwise. */
 int
 more_constrained (tree d1, tree d2)
 {
-tree c1 = get_constraints (d1);
+tree n1 = get_normalized_constraints_from_decl (d1);
-tree c2 = get_constraints (d2);
+tree n2 = get_normalized_constraints_from_decl (d2);
 int winner = 0;
-if (subsumes_constraints (c1, c2))
+if (subsumes (n1, n2))
 ++winner;
-if (subsumes_constraints (c2, c1))
+if (subsumes (n2, n1))
 --winner;
 return winner;
 }
-/* Returns true if D1 is at least as constrained as D2. That is, the
+/* Return whether D1 is at least as constrained as D2.  */
-associated constraints of D1 subsume those of D2, or both declarations
-are unconstrained. */
 bool
 at_least_as_constrained (tree d1, tree d2)
 {
-tree c1 = get_constraints (d1);
+tree n1 = get_normalized_constraints_from_decl (d1);
-tree c2 = get_constraints (d2);
+tree n2 = get_normalized_constraints_from_decl (d2);
-return subsumes_constraints (c1, c2);
-}
+return subsumes (n1, n2);
+}
 /*---------------------------------------------------------------------------
 Constraint diagnostics
-FIXME: Normalize expressions into constraints before evaluating them.
-This should be the general pattern for all such diagnostics.
 ---------------------------------------------------------------------------*/
-/* The number of detailed constraint failures.  */
+/* Returns the best location to diagnose a constraint error.  */
-int constraint_errors = 0;
+static location_t
+get_constraint_error_location (tree t)
-/* Do not generate errors after diagnosing this number of constraint
+{
-failures.
+/* If we have a specific location give it.  */
+tree expr = CONSTR_EXPR (t);
-FIXME: This is a really arbitrary number. Provide better control of
+if (location_t loc = cp_expr_location (expr))
-constraint diagnostics with a command line option.  */
+return loc;
-int constraint_thresh = 20;
+/* If the constraint is normalized from a requires-clause, give
+the location as that of the constrained declaration.  */
+tree cxt = CONSTR_CONTEXT (t);
-/* Returns true if we should elide the diagnostic for a constraint failure.
+tree src = TREE_VALUE (cxt);
-This is the case when the number of errors has exceeded the pre-configured
+if (!src)
-threshold.  */
+/* TODO: This only happens for constrained non-template declarations.  */
+return input_location;
-inline bool
+if (DECL_P (src))
-elide_constraint_failure_p ()
+return DECL_SOURCE_LOCATION (src);
-{
-bool ret = constraint_thresh <= constraint_errors;
+/* Otherwise, give the location as the defining concept.  */
-++constraint_errors;
+gcc_assert (concept_check_p (src));
-return ret;
+tree id = unpack_concept_check (src);
-}
+tree tmpl = TREE_OPERAND (id, 0);
+if (OVL_P (tmpl))
-/* Returns the number of undiagnosed errors. */
+tmpl = OVL_FIRST (tmpl);
+return DECL_SOURCE_LOCATION (tmpl);
-inline int
+}
-undiagnosed_constraint_failures ()
-{
+/* Emit a diagnostic for a failed trait.  */
-return constraint_errors - constraint_thresh;
-}
-/* The diagnosis of constraints performs a combination of normalization
-and satisfaction testing. We recursively walk through the conjunction or
-disjunction of associated constraints, testing each sub-constraint in
-turn.  */
-namespace {
-void diagnose_constraint (location_t, tree, tree, tree);
-/* Emit a specific diagnostics for a failed trait.  */
 void
-diagnose_trait_expression (location_t loc, tree, tree cur, tree args)
+diagnose_trait_expr (tree expr, tree args)
 {
-if (constraint_expression_satisfied_p (cur, args))
+location_t loc = cp_expr_location (expr);
-return;
-if (elide_constraint_failure_p())
+/* Build a "fake" version of the instantiated trait, so we can
-return;
+get the instantiated types from result.  */
-tree expr = PRED_CONSTR_EXPR (cur);
 ++processing_template_decl;
 expr = tsubst_expr (expr, args, tf_none, NULL_TREE, false);
 --processing_template_decl;
 tree t1 = TRAIT_EXPR_TYPE1 (expr);
 tree t2 = TRAIT_EXPR_TYPE2 (expr);
 switch (TRAIT_EXPR_KIND (expr))
 {
 case CPTK_HAS_NOTHROW_ASSIGN:
-inform (loc, "  %qT is not nothrow copy assignable", t1);
+inform (loc, "  %qT is not %<nothrow%> copy assignable", t1);
 break;
 case CPTK_HAS_NOTHROW_CONSTRUCTOR:
-inform (loc, "  %qT is not nothrow default constructible", t1);
+inform (loc, "  %qT is not %<nothrow%> default constructible", t1);
 break;
 case CPTK_HAS_NOTHROW_COPY:
-inform (loc, "  %qT is not nothrow copy constructible", t1);
+inform (loc, "  %qT is not %<nothrow%> copy constructible", t1);
 break;
 case CPTK_HAS_TRIVIAL_ASSIGN:
 inform (loc, "  %qT is not trivially copy assignable", t1);
 break;
 case CPTK_HAS_TRIVIAL_CONSTRUCTOR:
 default:
 gcc_unreachable ();
 }
 }
-/* Diagnose the expression of a predicate constraint.  */
+static tree
+diagnose_valid_expression (tree expr, tree args, tree in_decl)
-void
+{
-diagnose_other_expression (location_t loc, tree, tree cur, tree args)
+tree result = tsubst_expr (expr, args, tf_none, in_decl, false);
-{
+if (result != error_mark_node)
-if (constraint_expression_satisfied_p (cur, args))
+return result;
+location_t loc = cp_expr_loc_or_input_loc (expr);
+inform (loc, "the required expression %qE is invalid", expr);
+/* TODO: Replay the substitution to diagnose the error?  */
+// tsubst_expr (expr, args, tf_error, in_decl, false);
+return error_mark_node;
+}
+static tree
+diagnose_valid_type (tree type, tree args, tree in_decl)
+{
+tree result = tsubst (type, args, tf_none, in_decl);
+if (result != error_mark_node)
+return result;
+location_t loc = cp_expr_loc_or_input_loc (type);
+inform (loc, "the required type %qT is invalid", type);
+/* TODO: Replay the substitution to diagnose the error?  */
+// tsubst (type, args, tf_error, in_decl);
+return error_mark_node;
+}
+static void
+diagnose_simple_requirement (tree req, tree args, tree in_decl)
+{
+diagnose_valid_expression (TREE_OPERAND (req, 0), args, in_decl);
+}
+static void
+diagnose_compound_requirement (tree req, tree args, tree in_decl)
+{
+tree expr = TREE_OPERAND (req, 0);
+expr = diagnose_valid_expression (expr, args, in_decl);
+if (expr == error_mark_node)
 return;
-if (elide_constraint_failure_p())
+location_t loc = cp_expr_loc_or_input_loc (expr);
+/* Check the noexcept condition.  */
+if (COMPOUND_REQ_NOEXCEPT_P (req) && !expr_noexcept_p (expr, tf_none))
+inform (loc, "%qE is not %<noexcept%>", expr);
+tree type = TREE_OPERAND (req, 1);
+type = diagnose_valid_type (type, args, in_decl);
+if (type == error_mark_node)
 return;
-inform (loc, "%qE evaluated to false", cur);
-}
+if (type)
+{
-/* Do our best to infer meaning from predicates.  */
+subst_info quiet (tf_none, in_decl);
+subst_info noisy (tf_error, in_decl);
-inline void
-diagnose_predicate_constraint (location_t loc, tree orig, tree cur, tree args)
+/* Check the expression against the result type.  */
-{
+if (tree placeholder = type_uses_auto (type))
-if (TREE_CODE (PRED_CONSTR_EXPR (cur)) == TRAIT_EXPR)
+	{
-diagnose_trait_expression (loc, orig, cur, args);
+	  if (!type_deducible_p (expr, type, placeholder, args, quiet))
-else
+	    {
-diagnose_other_expression (loc, orig, cur, args);
+	      tree orig_expr = TREE_OPERAND (req, 0);
-}
+	      inform (loc, "%qE does not satisfy return-type-requirement",
+		      orig_expr);
-/* Diagnose a failed pack expansion, possibly containing constraints.  */
+	      /* Further explain the reason for the error.  */
-void
+	      type_deducible_p (expr, type, placeholder, args, noisy);
-diagnose_pack_expansion (location_t loc, tree, tree cur, tree args)
+	    }
-{
+	}
-if (constraint_expression_satisfied_p (cur, args))
+else if (!expression_convertible_p (expr, type, quiet))
+	{
+	  tree orig_expr = TREE_OPERAND (req, 0);
+	  inform (loc, "cannot convert %qE to %qT", orig_expr, type);
+	  /* Further explain the reason for the error.  */
+	  expression_convertible_p (expr, type, noisy);
+	}
+}
+}
+static void
+diagnose_type_requirement (tree req, tree args, tree in_decl)
+{
+tree type = TREE_OPERAND (req, 0);
+diagnose_valid_type (type, args, in_decl);
+}
+static void
+diagnose_nested_requirement (tree req, tree args)
+{
+/* Quietly check for satisfaction first. We can elaborate details
+later if needed.  */
+tree norm = TREE_VALUE (TREE_TYPE (req));
+subst_info info (tf_none, NULL_TREE);
+tree result = satisfy_constraint (norm, args, info);
+if (result == boolean_true_node)
 return;
-if (elide_constraint_failure_p())
+tree expr = TREE_OPERAND (req, 0);
+location_t loc = cp_expr_location (expr);
+inform (loc, "nested requirement %qE is not satisfied", expr);
+/* TODO: Replay the substitution to diagnose the error?  */
+// subst_info noisy (tf_warning_or_error, NULL_TREE);
+// satisfy_constraint (norm, args, info);
+}
+static void
+diagnose_requirement (tree req, tree args, tree in_decl)
+{
+iloc_sentinel loc_s (cp_expr_location (req));
+switch (TREE_CODE (req))
+{
+case SIMPLE_REQ:
+return diagnose_simple_requirement (req, args, in_decl);
+case COMPOUND_REQ:
+return diagnose_compound_requirement (req, args, in_decl);
+case TYPE_REQ:
+return diagnose_type_requirement (req, args, in_decl);
+case NESTED_REQ:
+return diagnose_nested_requirement (req, args);
+default:
+gcc_unreachable ();
+}
+}
+static void
+diagnose_requires_expr (tree expr, tree args, tree in_decl)
+{
+local_specialization_stack stack (lss_copy);
+tree parms = TREE_OPERAND (expr, 0);
+tree body = TREE_OPERAND (expr, 1);
+cp_unevaluated u;
+subst_info info (tf_warning_or_error, NULL_TREE);
+tree vars = tsubst_constraint_variables (parms, args, info);
+if (vars == error_mark_node)
 return;
-/* Make sure that we don't have naked packs that we don't expect. */
+tree p = body;
-if (!same_type_p (TREE_TYPE (cur), boolean_type_node))
+while (p)
 {
-inform (loc, "invalid pack expansion in constraint %qE", cur);
+tree req = TREE_VALUE (p);
+diagnose_requirement (req, args, in_decl);
+p = TREE_CHAIN (p);
+}
+}
+/* Diagnose a substitution failure in the atomic constraint T. Note that
+ARGS have been previously instantiated through the parameter map.  */
+static void
+diagnose_atomic_constraint (tree t, tree args, subst_info info)
+{
+/* If the constraint is already ill-formed, we've previously diagnosed
+the reason. We should still say why the constraints aren't satisfied.  */
+if (t == error_mark_node)
+{
+location_t loc;
+if (info.in_decl)
+loc = DECL_SOURCE_LOCATION (info.in_decl);
+else
+loc = input_location;
+inform (loc, "invalid constraints");
 return;
 }
-inform (loc, "in the expansion of %qE", cur);
+location_t loc = get_constraint_error_location (t);
+iloc_sentinel loc_s (loc);
-/* Get the vector of expanded arguments. Note that n must not
-be 0 since this constraint is not satisfied.  */
+/* Generate better diagnostics for certain kinds of expressions.  */
-++processing_template_decl;
+tree expr = ATOMIC_CONSTR_EXPR (t);
-tree exprs = tsubst_pack_expansion (cur, args, tf_none, NULL_TREE);
+STRIP_ANY_LOCATION_WRAPPER (expr);
---processing_template_decl;
+switch (TREE_CODE (expr))
-if (exprs == error_mark_node)
+{
-{
+case TRAIT_EXPR:
-/* TODO: This error message could be better. */
+diagnose_trait_expr (expr, args);
-inform (loc, "    substitution failure occurred during expansion");
-return;
-}
-/* Check each expanded constraint separately. */
-int n = TREE_VEC_LENGTH (exprs);
-for (int i = 0; i < n; ++i)
-{
-tree expr = TREE_VEC_ELT (exprs, i);
-if (!constraint_expression_satisfied_p (expr, args))
-inform (loc, "    %qE was not satisfied", expr);
-}
-}
-/* Diagnose a potentially unsatisfied concept check constraint DECL<CARGS>.
-Parameters are as for diagnose_constraint.  */
-void
-diagnose_check_constraint (location_t loc, tree orig, tree cur, tree args)
-{
-if (constraints_satisfied_p (cur, args))
-return;
-tree decl = CHECK_CONSTR_CONCEPT (cur);
-tree cargs = CHECK_CONSTR_ARGS (cur);
-tree tmpl = DECL_TI_TEMPLATE (decl);
-tree check = build_nt (CHECK_CONSTR, decl, cargs);
-/* Instantiate the concept check arguments.  */
-tree targs = tsubst (cargs, args, tf_none, NULL_TREE);
-if (targs == error_mark_node)
-{
-if (elide_constraint_failure_p ())
-return;
-inform (loc, "invalid use of the concept %qE", check);
-tsubst (cargs, args, tf_warning_or_error, NULL_TREE);
-return;
-}
-tree sub = build_tree_list (tmpl, targs);
-/* Update to the expanded definitions. */
-cur = expand_concept (decl, targs);
-if (cur == error_mark_node)
-{
-if (elide_constraint_failure_p ())
-return;
-inform (loc, "in the expansion of concept %<%E %S%>", check, sub);
-cur = get_concept_definition (decl);
-tsubst_expr (cur, targs, tf_warning_or_error, NULL_TREE, false);
-return;
-}
-orig = get_concept_definition (CHECK_CONSTR_CONCEPT (orig));
-orig = normalize_expression (orig);
-location_t dloc = DECL_SOURCE_LOCATION (decl);
-inform (dloc, "within %qS", sub);
-diagnose_constraint (dloc, orig, cur, targs);
-}
-/* Diagnose a potentially unsatisfied conjunction or disjunction.  Parameters
-are as for diagnose_constraint.  */
-void
-diagnose_logical_constraint (location_t loc, tree orig, tree cur, tree args)
-{
-tree t0 = TREE_OPERAND (cur, 0);
-tree t1 = TREE_OPERAND (cur, 1);
-if (!constraints_satisfied_p (t0, args))
-diagnose_constraint (loc, TREE_OPERAND (orig, 0), t0, args);
-else if (TREE_CODE (orig) == TRUTH_ORIF_EXPR)
-return;
-if (!constraints_satisfied_p (t1, args))
-diagnose_constraint (loc, TREE_OPERAND (orig, 1), t1, args);
-}
-/* Diagnose a potential expression constraint failure. */
-void
-diagnose_expression_constraint (location_t loc, tree orig, tree cur, tree args)
-{
-if (constraints_satisfied_p (cur, args))
-return;
-if (elide_constraint_failure_p())
-return;
-tree expr = EXPR_CONSTR_EXPR (orig);
-inform (loc, "the required expression %qE would be ill-formed", expr);
-// TODO: We should have a flag that controls this substitution.
-// I'm finding it very useful for resolving concept check errors.
-// inform (input_location, "==== BEGIN DUMP ====");
-// tsubst_expr (EXPR_CONSTR_EXPR (orig), args, tf_warning_or_error, NULL_TREE, false);
-// inform (input_location, "==== END DUMP ====");
-}
-/* Diagnose a potentially failed type constraint. */
-void
-diagnose_type_constraint (location_t loc, tree orig, tree cur, tree args)
-{
-if (constraints_satisfied_p (cur, args))
-return;
-if (elide_constraint_failure_p())
-return;
-tree type = TYPE_CONSTR_TYPE (orig);
-inform (loc, "the required type %qT would be ill-formed", type);
-}
-/* Diagnose a potentially unsatisfied conversion constraint. */
-void
-diagnose_implicit_conversion_constraint (location_t loc, tree orig, tree cur,
-					 tree args)
-{
-if (constraints_satisfied_p (cur, args))
-return;
-/* The expression and type will previously have been substituted into,
-and therefore may already be an error. Also, we will have already
-diagnosed substitution failures into an expression since this must be
-part of a compound requirement.  */
-tree expr = ICONV_CONSTR_EXPR (cur);
-if (error_operand_p (expr))
-return;
-/* Don't elide a previously diagnosed failure.  */
-if (elide_constraint_failure_p())
-return;
-tree type = ICONV_CONSTR_TYPE (cur);
-if (error_operand_p (type))
-{
-inform (loc, "substitution into type %qT failed",
-	      ICONV_CONSTR_TYPE (orig));
-return;
-}
-inform(loc, "%qE is not implicitly convertible to %qT", expr, type);
-}
-/* Diagnose an argument deduction constraint. */
-void
-diagnose_argument_deduction_constraint (location_t loc, tree orig, tree cur,
-					tree args)
-{
-if (constraints_satisfied_p (cur, args))
-return;
-/* The expression and type will previously have been substituted into,
-and therefore may already be an error. Also, we will have already
-diagnosed substution failures into an expression since this must be
-part of a compound requirement.  */
-tree expr = DEDUCT_CONSTR_EXPR (cur);
-if (error_operand_p (expr))
-return;
-/* Don't elide a previously diagnosed failure.  */
-if (elide_constraint_failure_p ())
-return;
-tree pattern = DEDUCT_CONSTR_PATTERN (cur);
-if (error_operand_p (pattern))
-{
-inform (loc, "substitution into type %qT failed",
-	      DEDUCT_CONSTR_PATTERN (orig));
-return;
-}
-inform (loc, "unable to deduce placeholder type %qT from %qE",
-	  pattern, expr);
-}
-/* Diagnose an exception constraint. */
-void
-diagnose_exception_constraint (location_t loc, tree orig, tree cur, tree args)
-{
-if (constraints_satisfied_p (cur, args))
-return;
-if (elide_constraint_failure_p ())
-return;
-/* Rebuild a noexcept expression. */
-tree expr = EXCEPT_CONSTR_EXPR (cur);
-if (error_operand_p (expr))
-return;
-inform (loc, "%qE evaluated to false", EXCEPT_CONSTR_EXPR (orig));
-}
-/* Diagnose a potentially unsatisfied parameterized constraint.  */
-void
-diagnose_parameterized_constraint (location_t loc, tree orig, tree cur,
-				   tree args)
-{
-if (constraints_satisfied_p (cur, args))
-return;
-local_specialization_stack stack;
-tree parms = PARM_CONSTR_PARMS (cur);
-tree vars = tsubst_constraint_variables (parms, args, tf_warning_or_error,
-					   NULL_TREE);
-if (vars == error_mark_node)
-{
-if (elide_constraint_failure_p ())
-return;
-/* TODO: Check which variable failed and use orig to diagnose
-that substitution error.  */
-inform (loc, "failed to instantiate constraint variables");
-return;
-}
-/* TODO: It would be better write these in a list. */
-while (vars)
-{
-inform (loc, "    with %q#D", vars);
-vars = TREE_CHAIN (vars);
-}
-orig = PARM_CONSTR_OPERAND (orig);
-cur = PARM_CONSTR_OPERAND (cur);
-return diagnose_constraint (loc, orig, cur, args);
-}
-/* Diagnose the constraint CUR for the given ARGS. This is only ever invoked
-on the associated constraints, so we can only have conjunctions of
-predicate constraints.  The ORIGinal (dependent) constructs follow
-the current constraints to enable better diagnostics.  Note that ORIG
-and CUR must be the same kinds of node, except when CUR is an error.  */
-void
-diagnose_constraint (location_t loc, tree orig, tree cur, tree args)
-{
-switch (TREE_CODE (cur))
-{
-case EXPR_CONSTR:
-diagnose_expression_constraint (loc, orig, cur, args);
 break;
+case REQUIRES_EXPR:
-case TYPE_CONSTR:
+diagnose_requires_expr (expr, args, info.in_decl);
-diagnose_type_constraint (loc, orig, cur, args);
 break;
+case INTEGER_CST:
-case ICONV_CONSTR:
+/* This must be either 0 or false.  */
-diagnose_implicit_conversion_constraint (loc, orig, cur, args);
+inform (loc, "%qE is never satisfied", expr);
 break;
-case DEDUCT_CONSTR:
-diagnose_argument_deduction_constraint (loc, orig, cur, args);
-break;
-case EXCEPT_CONSTR:
-diagnose_exception_constraint (loc, orig, cur, args);
-break;
-case CONJ_CONSTR:
-case DISJ_CONSTR:
-diagnose_logical_constraint (loc, orig, cur, args);
-break;
-case PRED_CONSTR:
-diagnose_predicate_constraint (loc, orig, cur, args);
-break;
-case PARM_CONSTR:
-diagnose_parameterized_constraint (loc, orig, cur, args);
-break;
-case CHECK_CONSTR:
-diagnose_check_constraint (loc, orig, cur, args);
-break;
-case EXPR_PACK_EXPANSION:
-diagnose_pack_expansion (loc, orig, cur, args);
-break;
-case ERROR_MARK:
-/* TODO: Can we improve the diagnostic with the original?  */
-inform (input_location, "ill-formed constraint");
-break;
 default:
-gcc_unreachable ();
+inform (loc, "the expression %qE evaluated to %<false%>", expr);
-break;
+}
 }
-}
+GTY(()) tree current_failed_constraint;
-/* Diagnose the reason(s) why ARGS do not satisfy the constraints
-of declaration DECL. */
+diagnosing_failed_constraint::
+diagnosing_failed_constraint (tree t, tree args, bool diag)
-void
+: diagnosing_error (diag)
-diagnose_declaration_constraints (location_t loc, tree decl, tree args)
+{
-{
+if (diagnosing_error)
-inform (loc, "  constraints not satisfied");
+current_failed_constraint = tree_cons (args, t, current_failed_constraint);
+}
-/* Constraints are attached to the template.  */
-if (tree ti = DECL_TEMPLATE_INFO (decl))
+diagnosing_failed_constraint::
-{
+~diagnosing_failed_constraint ()
-decl = TI_TEMPLATE (ti);
+{
-if (!args)
+if (diagnosing_error && current_failed_constraint)
-	args = TI_ARGS (ti);
+current_failed_constraint = TREE_CHAIN (current_failed_constraint);
 }
-/* Recursively diagnose the associated constraints.  */
+/* Emit diagnostics detailing the failure ARGS to satisfy the constraints
-tree ci = get_constraints (decl);
+of T. Here, T can be either a constraint or a declaration.  */
-tree t = CI_ASSOCIATED_CONSTRAINTS (ci);
-diagnose_constraint (loc, t, t, args);
-}
-} // namespace
-/* Emit diagnostics detailing the failure ARGS to satisfy the
-constraints of T. Here, T can be either a constraint
-or a declaration.  */
 void
 diagnose_constraints (location_t loc, tree t, tree args)
 {
-constraint_errors = 0;
+inform (loc, "constraints not satisfied");
-if (constraint_p (t))
+/* Replay satisfaction, but diagnose errors.  */
-diagnose_constraint (loc, t, t, args);
+if (!args)
-else if (DECL_P (t))
+constraint_satisfaction_value (t, tf_warning_or_error);
-diagnose_declaration_constraints (loc, t, args);
 else
-gcc_unreachable ();
+constraint_satisfaction_value (t, args, tf_warning_or_error);
+}
-/* Note the number of elided failures. */
-int n = undiagnosed_constraint_failures ();
+#include "gt-cp-constraint.h"
-if (n > 0)
-inform (loc, "... and %d more constraint errors not shown", n);
-}

Mercurial > hg > CbC > CbC_gcc

comparison gcc/cp/constraint.cc @ 145:1830386684a0