1/* Processing rules for constraints. 2 Copyright (C) 2013-2020 Free Software Foundation, Inc. 3 Contributed by Andrew Sutton (andrew.n.sutton@gmail.com) 4 5This file is part of GCC. 6 7GCC is free software; you can redistribute it and/or modify 8it under the terms of the GNU General Public License as published by 9the Free Software Foundation; either version 3, or (at your option) 10any later version. 11 12GCC is distributed in the hope that it will be useful, 13but WITHOUT ANY WARRANTY; without even the implied warranty of 14MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15GNU General Public License for more details. 16 17You should have received a copy of the GNU General Public License 18along with GCC; see the file COPYING3. If not see 19<http://www.gnu.org/licenses/>. */ 20 21#include "config.h" 22#include "system.h" 23#include "coretypes.h" 24#include "tm.h" 25#include "timevar.h" 26#include "hash-set.h" 27#include "machmode.h" 28#include "vec.h" 29#include "double-int.h" 30#include "input.h" 31#include "alias.h" 32#include "symtab.h" 33#include "wide-int.h" 34#include "inchash.h" 35#include "tree.h" 36#include "stringpool.h" 37#include "attribs.h" 38#include "intl.h" 39#include "flags.h" 40#include "cp-tree.h" 41#include "c-family/c-common.h" 42#include "c-family/c-objc.h" 43#include "cp-objcp-common.h" 44#include "tree-inline.h" 45#include "decl.h" 46#include "toplev.h" 47#include "type-utils.h" 48 49static tree satisfaction_value (tree t); 50 51/* When we're parsing or substuting a constraint expression, we have slightly 52 different expression semantics. In particular, we don't want to reduce a 53 concept-id to a satisfaction value. */ 54 55processing_constraint_expression_sentinel:: 56processing_constraint_expression_sentinel () 57{ 58 ++scope_chain->x_processing_constraint; 59} 60 61processing_constraint_expression_sentinel:: 62~processing_constraint_expression_sentinel () 63{ 64 --scope_chain->x_processing_constraint; 65} 66 67bool 68processing_constraint_expression_p () 69{ 70 return scope_chain->x_processing_constraint != 0; 71} 72 73/*--------------------------------------------------------------------------- 74 Constraint expressions 75---------------------------------------------------------------------------*/ 76 77/* Information provided to substitution. */ 78 79struct subst_info 80{ 81 subst_info (tsubst_flags_t cmp, tree in) 82 : complain (cmp), in_decl (in) 83 { } 84 85 /* True if we should not diagnose errors. */ 86 bool quiet() const 87 { 88 return complain == tf_none; 89 } 90 91 /* True if we should diagnose errors. */ 92 bool noisy() const 93 { 94 return !quiet (); 95 } 96 97 tsubst_flags_t complain; 98 tree in_decl; 99}; 100 101static tree satisfy_constraint (tree, tree, subst_info); 102 103/* True if T is known to be some type other than bool. Note that this 104 is false for dependent types and errors. */ 105 106static inline bool 107known_non_bool_p (tree t) 108{ 109 return (t && !WILDCARD_TYPE_P (t) && TREE_CODE (t) != BOOLEAN_TYPE); 110} 111 112static bool 113check_constraint_atom (cp_expr expr) 114{ 115 if (known_non_bool_p (TREE_TYPE (expr))) 116 { 117 error_at (expr.get_location (), 118 "constraint expression does not have type %<bool%>"); 119 return false; 120 } 121 122 /* Check that we're using function concepts correctly. */ 123 if (concept_check_p (expr)) 124 { 125 tree id = unpack_concept_check (expr); 126 tree tmpl = TREE_OPERAND (id, 0); 127 if (OVL_P (tmpl) && TREE_CODE (expr) == TEMPLATE_ID_EXPR) 128 { 129 error_at (EXPR_LOC_OR_LOC (expr, input_location), 130 "function concept must be called"); 131 return false; 132 } 133 } 134 135 return true; 136} 137 138static bool 139check_constraint_operands (location_t, cp_expr lhs, cp_expr rhs) 140{ 141 return check_constraint_atom (lhs) && check_constraint_atom (rhs); 142} 143 144/* Validate the semantic properties of the constraint expression. */ 145 146static cp_expr 147finish_constraint_binary_op (location_t loc, 148 tree_code code, 149 cp_expr lhs, 150 cp_expr rhs) 151{ 152 gcc_assert (processing_constraint_expression_p ()); 153 if (lhs == error_mark_node || rhs == error_mark_node) 154 return error_mark_node; 155 if (!check_constraint_operands (loc, lhs, rhs)) 156 return error_mark_node; 157 tree overload; 158 cp_expr expr = build_x_binary_op (loc, code, 159 lhs, TREE_CODE (lhs), 160 rhs, TREE_CODE (rhs), 161 &overload, tf_none); 162 /* When either operand is dependent, the overload set may be non-empty. */ 163 if (expr == error_mark_node) 164 return error_mark_node; 165 expr.set_location (loc); 166 expr.set_range (lhs.get_start (), rhs.get_finish ()); 167 return expr; 168} 169 170cp_expr 171finish_constraint_or_expr (location_t loc, cp_expr lhs, cp_expr rhs) 172{ 173 return finish_constraint_binary_op (loc, TRUTH_ORIF_EXPR, lhs, rhs); 174} 175 176cp_expr 177finish_constraint_and_expr (location_t loc, cp_expr lhs, cp_expr rhs) 178{ 179 return finish_constraint_binary_op (loc, TRUTH_ANDIF_EXPR, lhs, rhs); 180} 181 182cp_expr 183finish_constraint_primary_expr (cp_expr expr) 184{ 185 if (expr == error_mark_node) 186 return error_mark_node; 187 if (!check_constraint_atom (expr)) 188 return cp_expr (error_mark_node, expr.get_location ()); 189 return expr; 190} 191 192/* Combine two constraint-expressions with a logical-and. */ 193 194tree 195combine_constraint_expressions (tree lhs, tree rhs) 196{ 197 processing_constraint_expression_sentinel pce; 198 if (!lhs) 199 return rhs; 200 if (!rhs) 201 return lhs; 202 return finish_constraint_and_expr (input_location, lhs, rhs); 203} 204 205/* Extract the template-id from a concept check. For standard and variable 206 checks, this is simply T. For function concept checks, this is the 207 called function. */ 208 209tree 210unpack_concept_check (tree t) 211{ 212 gcc_assert (concept_check_p (t)); 213 214 if (TREE_CODE (t) == CALL_EXPR) 215 t = CALL_EXPR_FN (t); 216 217 gcc_assert (TREE_CODE (t) == TEMPLATE_ID_EXPR); 218 return t; 219} 220 221/* Extract the TEMPLATE_DECL from a concept check. */ 222 223tree 224get_concept_check_template (tree t) 225{ 226 tree id = unpack_concept_check (t); 227 tree tmpl = TREE_OPERAND (id, 0); 228 if (OVL_P (tmpl)) 229 tmpl = OVL_FIRST (tmpl); 230 return tmpl; 231} 232 233/* Returns true if any of the arguments in the template argument list is 234 a wildcard or wildcard pack. */ 235 236bool 237contains_wildcard_p (tree args) 238{ 239 for (int i = 0; i < TREE_VEC_LENGTH (args); ++i) 240 { 241 tree arg = TREE_VEC_ELT (args, i); 242 if (TREE_CODE (arg) == WILDCARD_DECL) 243 return true; 244 } 245 return false; 246} 247 248/*--------------------------------------------------------------------------- 249 Resolution of qualified concept names 250---------------------------------------------------------------------------*/ 251 252/* This facility is used to resolve constraint checks from requirement 253 expressions. A constraint check is a call to a function template declared 254 with the keyword 'concept'. 255 256 The result of resolution is a pair (a TREE_LIST) whose value is the 257 matched declaration, and whose purpose contains the coerced template 258 arguments that can be substituted into the call. */ 259 260/* Given an overload set OVL, try to find a unique definition that can be 261 instantiated by the template arguments ARGS. 262 263 This function is not called for arbitrary call expressions. In particular, 264 the call expression must be written with explicit template arguments 265 and no function arguments. For example: 266 267 f<T, U>() 268 269 If a single match is found, this returns a TREE_LIST whose VALUE 270 is the constraint function (not the template), and its PURPOSE is 271 the complete set of arguments substituted into the parameter list. */ 272 273static tree 274resolve_function_concept_overload (tree ovl, tree args) 275{ 276 int nerrs = 0; 277 tree cands = NULL_TREE; 278 for (lkp_iterator iter (ovl); iter; ++iter) 279 { 280 tree tmpl = *iter; 281 if (TREE_CODE (tmpl) != TEMPLATE_DECL) 282 continue; 283 284 /* Don't try to deduce checks for non-concepts. We often end up trying 285 to resolve constraints in functional casts as part of a 286 postfix-expression. We can save time and headaches by not 287 instantiating those declarations. 288 289 NOTE: This masks a potential error, caused by instantiating 290 non-deduced contexts using placeholder arguments. */ 291 tree fn = DECL_TEMPLATE_RESULT (tmpl); 292 if (DECL_ARGUMENTS (fn)) 293 continue; 294 if (!DECL_DECLARED_CONCEPT_P (fn)) 295 continue; 296 297 /* Remember the candidate if we can deduce a substitution. */ 298 ++processing_template_decl; 299 tree parms = TREE_VALUE (DECL_TEMPLATE_PARMS (tmpl)); 300 if (tree subst = coerce_template_parms (parms, args, tmpl)) 301 { 302 if (subst == error_mark_node) 303 ++nerrs; 304 else 305 cands = tree_cons (subst, fn, cands); 306 } 307 --processing_template_decl; 308 } 309 310 if (!cands) 311 /* We either had no candidates or failed deductions. */ 312 return nerrs ? error_mark_node : NULL_TREE; 313 else if (TREE_CHAIN (cands)) 314 /* There are multiple candidates. */ 315 return error_mark_node; 316 317 return cands; 318} 319 320/* Determine if the call expression CALL is a constraint check, and 321 return the concept declaration and arguments being checked. If CALL 322 does not denote a constraint check, return NULL. */ 323 324tree 325resolve_function_concept_check (tree call) 326{ 327 gcc_assert (TREE_CODE (call) == CALL_EXPR); 328 329 /* A constraint check must be only a template-id expression. 330 If it's a call to a base-link, its function(s) should be a 331 template-id expression. If this is not a template-id, then 332 it cannot be a concept-check. */ 333 tree target = CALL_EXPR_FN (call); 334 if (BASELINK_P (target)) 335 target = BASELINK_FUNCTIONS (target); 336 if (TREE_CODE (target) != TEMPLATE_ID_EXPR) 337 return NULL_TREE; 338 339 /* Get the overload set and template arguments and try to 340 resolve the target. */ 341 tree ovl = TREE_OPERAND (target, 0); 342 343 /* This is a function call of a variable concept... ill-formed. */ 344 if (TREE_CODE (ovl) == TEMPLATE_DECL) 345 { 346 error_at (location_of (call), 347 "function call of variable concept %qE", call); 348 return error_mark_node; 349 } 350 351 tree args = TREE_OPERAND (target, 1); 352 return resolve_function_concept_overload (ovl, args); 353} 354 355/* Returns a pair containing the checked concept and its associated 356 prototype parameter. The result is a TREE_LIST whose TREE_VALUE 357 is the concept (non-template) and whose TREE_PURPOSE contains 358 the converted template arguments, including the deduced prototype 359 parameter (in position 0). */ 360 361tree 362resolve_concept_check (tree check) 363{ 364 gcc_assert (concept_check_p (check)); 365 tree id = unpack_concept_check (check); 366 tree tmpl = TREE_OPERAND (id, 0); 367 368 /* If this is an overloaded function concept, perform overload 369 resolution (this only happens when deducing prototype parameters 370 and template introductions). */ 371 if (TREE_CODE (tmpl) == OVERLOAD) 372 { 373 if (OVL_CHAIN (tmpl)) 374 return resolve_function_concept_check (check); 375 tmpl = OVL_FIRST (tmpl); 376 } 377 378 tree args = TREE_OPERAND (id, 1); 379 tree parms = INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (tmpl)); 380 ++processing_template_decl; 381 tree result = coerce_template_parms (parms, args, tmpl); 382 --processing_template_decl; 383 if (result == error_mark_node) 384 return error_mark_node; 385 return build_tree_list (result, DECL_TEMPLATE_RESULT (tmpl)); 386} 387 388/* Given a call expression or template-id expression to a concept EXPR 389 possibly including a wildcard, deduce the concept being checked and 390 the prototype parameter. Returns true if the constraint and prototype 391 can be deduced and false otherwise. Note that the CHECK and PROTO 392 arguments are set to NULL_TREE if this returns false. */ 393 394bool 395deduce_constrained_parameter (tree expr, tree& check, tree& proto) 396{ 397 tree info = resolve_concept_check (expr); 398 if (info && info != error_mark_node) 399 { 400 check = TREE_VALUE (info); 401 tree arg = TREE_VEC_ELT (TREE_PURPOSE (info), 0); 402 if (ARGUMENT_PACK_P (arg)) 403 arg = TREE_VEC_ELT (ARGUMENT_PACK_ARGS (arg), 0); 404 proto = TREE_TYPE (arg); 405 return true; 406 } 407 408 check = proto = NULL_TREE; 409 return false; 410} 411 412/* Given a call expression or template-id expression to a concept, EXPR, 413 deduce the concept being checked and return the template arguments. 414 Returns NULL_TREE if deduction fails. */ 415static tree 416deduce_concept_introduction (tree check) 417{ 418 tree info = resolve_concept_check (check); 419 if (info && info != error_mark_node) 420 return TREE_PURPOSE (info); 421 return NULL_TREE; 422} 423 424/* Build a constrained placeholder type where SPEC is a type-constraint. 425 SPEC can be anything were concept_definition_p is true. 426 427 If DECLTYPE_P is true, then the placeholder is decltype(auto). 428 429 Returns a pair whose FIRST is the concept being checked and whose 430 SECOND is the prototype parameter. */ 431 432tree_pair 433finish_type_constraints (tree spec, tree args, tsubst_flags_t complain) 434{ 435 gcc_assert (concept_definition_p (spec)); 436 437 /* Build an initial concept check. */ 438 tree check = build_type_constraint (spec, args, complain); 439 if (check == error_mark_node) 440 return std::make_pair (error_mark_node, NULL_TREE); 441 442 /* Extract the concept and prototype parameter from the check. */ 443 tree con; 444 tree proto; 445 if (!deduce_constrained_parameter (check, con, proto)) 446 return std::make_pair (error_mark_node, NULL_TREE); 447 448 return std::make_pair (con, proto); 449} 450 451/*--------------------------------------------------------------------------- 452 Expansion of concept definitions 453---------------------------------------------------------------------------*/ 454 455/* Returns the expression of a function concept. */ 456 457static tree 458get_returned_expression (tree fn) 459{ 460 /* Extract the body of the function minus the return expression. */ 461 tree body = DECL_SAVED_TREE (fn); 462 if (!body) 463 return error_mark_node; 464 if (TREE_CODE (body) == BIND_EXPR) 465 body = BIND_EXPR_BODY (body); 466 if (TREE_CODE (body) != RETURN_EXPR) 467 return error_mark_node; 468 469 return TREE_OPERAND (body, 0); 470} 471 472/* Returns the initializer of a variable concept. */ 473 474static tree 475get_variable_initializer (tree var) 476{ 477 tree init = DECL_INITIAL (var); 478 if (!init) 479 return error_mark_node; 480 if (BRACE_ENCLOSED_INITIALIZER_P (init) 481 && CONSTRUCTOR_NELTS (init) == 1) 482 init = CONSTRUCTOR_ELT (init, 0)->value; 483 return init; 484} 485 486/* Returns the definition of a variable or function concept. */ 487 488static tree 489get_concept_definition (tree decl) 490{ 491 if (TREE_CODE (decl) == OVERLOAD) 492 decl = OVL_FIRST (decl); 493 494 if (TREE_CODE (decl) == TEMPLATE_DECL) 495 decl = DECL_TEMPLATE_RESULT (decl); 496 497 if (TREE_CODE (decl) == CONCEPT_DECL) 498 return DECL_INITIAL (decl); 499 if (VAR_P (decl)) 500 return get_variable_initializer (decl); 501 if (TREE_CODE (decl) == FUNCTION_DECL) 502 return get_returned_expression (decl); 503 gcc_unreachable (); 504} 505 506/*--------------------------------------------------------------------------- 507 Normalization of expressions 508 509This set of functions will transform an expression into a constraint 510in a sequence of steps. 511---------------------------------------------------------------------------*/ 512 513void 514debug_parameter_mapping (tree map) 515{ 516 for (tree p = map; p; p = TREE_CHAIN (p)) 517 { 518 tree parm = TREE_VALUE (p); 519 tree arg = TREE_PURPOSE (p); 520 if (TYPE_P (parm)) 521 verbatim ("MAP %qD TO %qT", TEMPLATE_TYPE_DECL (parm), arg); 522 else 523 verbatim ("MAP %qD TO %qE", TEMPLATE_PARM_DECL (parm), arg); 524 // debug_tree (parm); 525 // debug_tree (arg); 526 } 527} 528 529void 530debug_argument_list (tree args) 531{ 532 for (int i = 0; i < TREE_VEC_LENGTH (args); ++i) 533 { 534 tree arg = TREE_VEC_ELT (args, i); 535 if (TYPE_P (arg)) 536 verbatim ("ARG %qT", arg); 537 else 538 verbatim ("ARG %qE", arg); 539 } 540} 541 542/* Associate each parameter in PARMS with its corresponding template 543 argument in ARGS. */ 544 545static tree 546map_arguments (tree parms, tree args) 547{ 548 for (tree p = parms; p; p = TREE_CHAIN (p)) 549 if (args) 550 { 551 int level; 552 int index; 553 template_parm_level_and_index (TREE_VALUE (p), &level, &index); 554 TREE_PURPOSE (p) = TMPL_ARG (args, level, index); 555 } 556 else 557 TREE_PURPOSE (p) = template_parm_to_arg (p); 558 559 return parms; 560} 561 562/* Build the parameter mapping for EXPR using ARGS. */ 563 564static tree 565build_parameter_mapping (tree expr, tree args, tree decl) 566{ 567 tree ctx_parms = NULL_TREE; 568 if (decl) 569 { 570 gcc_assert (TREE_CODE (decl) == TEMPLATE_DECL); 571 ctx_parms = DECL_TEMPLATE_PARMS (decl); 572 } 573 else if (current_template_parms) 574 { 575 /* TODO: This should probably be the only case, but because the 576 point of declaration of concepts is currently set after the 577 initializer, the template parameter lists are not available 578 when normalizing concept definitions, hence the case above. */ 579 ctx_parms = current_template_parms; 580 } 581 582 tree parms = find_template_parameters (expr, ctx_parms); 583 tree map = map_arguments (parms, args); 584 return map; 585} 586 587/* True if the parameter mappings of two atomic constraints are equivalent. */ 588 589static bool 590parameter_mapping_equivalent_p (tree t1, tree t2) 591{ 592 tree map1 = ATOMIC_CONSTR_MAP (t1); 593 tree map2 = ATOMIC_CONSTR_MAP (t2); 594 while (map1 && map2) 595 { 596 tree arg1 = TREE_PURPOSE (map1); 597 tree arg2 = TREE_PURPOSE (map2); 598 if (!template_args_equal (arg1, arg2)) 599 return false; 600 map1 = TREE_CHAIN (map1); 601 map2 = TREE_CHAIN (map2); 602 } 603 return true; 604} 605 606/* Provides additional context for normalization. */ 607 608struct norm_info : subst_info 609{ 610 explicit norm_info (tsubst_flags_t complain) 611 : subst_info (tf_warning_or_error | complain, NULL_TREE), 612 context() 613 {} 614 615 /* Construct a top-level context for DECL. */ 616 617 norm_info (tree in_decl, tsubst_flags_t complain) 618 : subst_info (tf_warning_or_error | complain, in_decl), 619 context (make_context (in_decl)) 620 {} 621 622 bool generate_diagnostics() const 623 { 624 return complain & tf_norm; 625 } 626 627 tree make_context(tree in_decl) 628 { 629 if (generate_diagnostics ()) 630 return build_tree_list (NULL_TREE, in_decl); 631 return NULL_TREE; 632 } 633 634 void update_context(tree expr, tree args) 635 { 636 if (generate_diagnostics ()) 637 { 638 tree map = build_parameter_mapping (expr, args, in_decl); 639 context = tree_cons (map, expr, context); 640 } 641 in_decl = get_concept_check_template (expr); 642 } 643 644 /* Provides information about the source of a constraint. This is a 645 TREE_LIST whose VALUE is either a concept check or a constrained 646 declaration. The PURPOSE, for concept checks is a parameter mapping 647 for that check. */ 648 649 tree context; 650}; 651 652static tree normalize_expression (tree, tree, norm_info); 653 654/* Transform a logical-or or logical-and expression into either 655 a conjunction or disjunction. */ 656 657static tree 658normalize_logical_operation (tree t, tree args, tree_code c, norm_info info) 659{ 660 tree t0 = normalize_expression (TREE_OPERAND (t, 0), args, info); 661 tree t1 = normalize_expression (TREE_OPERAND (t, 1), args, info); 662 663 /* Build a new info object for the constraint. */ 664 tree ci = info.generate_diagnostics() 665 ? build_tree_list (t, info.context) 666 : NULL_TREE; 667 668 return build2 (c, ci, t0, t1); 669} 670 671static tree 672normalize_concept_check (tree check, tree args, norm_info info) 673{ 674 tree id = unpack_concept_check (check); 675 tree tmpl = TREE_OPERAND (id, 0); 676 tree targs = TREE_OPERAND (id, 1); 677 678 /* A function concept is wrapped in an overload. */ 679 if (TREE_CODE (tmpl) == OVERLOAD) 680 { 681 /* TODO: Can we diagnose this error during parsing? */ 682 if (TREE_CODE (check) == TEMPLATE_ID_EXPR) 683 error_at (EXPR_LOC_OR_LOC (check, input_location), 684 "function concept must be called"); 685 tmpl = OVL_FIRST (tmpl); 686 } 687 688 /* Substitute through the arguments of the concept check. */ 689 if (args) 690 targs = tsubst_template_args (targs, args, info.complain, info.in_decl); 691 if (targs == error_mark_node) 692 return error_mark_node; 693 694 /* Build the substitution for the concept definition. */ 695 tree parms = TREE_VALUE (DECL_TEMPLATE_PARMS (tmpl)); 696 /* Turn on template processing; coercing non-type template arguments 697 will automatically assume they're non-dependent. */ 698 ++processing_template_decl; 699 tree subst = coerce_template_parms (parms, targs, tmpl); 700 --processing_template_decl; 701 if (subst == error_mark_node) 702 return error_mark_node; 703 704 /* The concept may have been ill-formed. */ 705 tree def = get_concept_definition (DECL_TEMPLATE_RESULT (tmpl)); 706 if (def == error_mark_node) 707 return error_mark_node; 708 709 info.update_context (check, args); 710 return normalize_expression (def, subst, info); 711} 712 713/* The normal form of an atom depends on the expression. The normal 714 form of a function call to a function concept is a check constraint 715 for that concept. The normal form of a reference to a variable 716 concept is a check constraint for that concept. Otherwise, the 717 constraint is a predicate constraint. */ 718 719static tree 720normalize_atom (tree t, tree args, norm_info info) 721{ 722 /* Concept checks are not atomic. */ 723 if (concept_check_p (t)) 724 return normalize_concept_check (t, args, info); 725 726 /* Build the parameter mapping for the atom. */ 727 tree map = build_parameter_mapping (t, args, info.in_decl); 728 729 /* Build a new info object for the atom. */ 730 tree ci = build_tree_list (t, info.context); 731 732 return build1 (ATOMIC_CONSTR, ci, map); 733} 734 735/* Returns the normal form of an expression. */ 736 737static tree 738normalize_expression (tree t, tree args, norm_info info) 739{ 740 if (!t) 741 return NULL_TREE; 742 743 if (t == error_mark_node) 744 return error_mark_node; 745 746 switch (TREE_CODE (t)) 747 { 748 case TRUTH_ANDIF_EXPR: 749 return normalize_logical_operation (t, args, CONJ_CONSTR, info); 750 case TRUTH_ORIF_EXPR: 751 return normalize_logical_operation (t, args, DISJ_CONSTR, info); 752 default: 753 return normalize_atom (t, args, info); 754 } 755} 756 757/* Cache of the normalized form of constraints. Marked as deletable because it 758 can all be recalculated. */ 759static GTY((deletable)) hash_map<tree,tree> *normalized_map; 760 761static tree 762get_normalized_constraints (tree t, tree args, norm_info info) 763{ 764 auto_timevar time (TV_CONSTRAINT_NORM); 765 return normalize_expression (t, args, info); 766} 767 768/* Returns the normalized constraints from a constraint-info object 769 or NULL_TREE if the constraints are null. ARGS provide the initial 770 arguments for normalization and IN_DECL provides the declaration 771 to which the constraints belong. */ 772 773static tree 774get_normalized_constraints_from_info (tree ci, tree args, tree in_decl, 775 bool diag = false) 776{ 777 if (ci == NULL_TREE) 778 return NULL_TREE; 779 780 /* Substitution errors during normalization are fatal. */ 781 ++processing_template_decl; 782 norm_info info (in_decl, diag ? tf_norm : tf_none); 783 tree t = get_normalized_constraints (CI_ASSOCIATED_CONSTRAINTS (ci), 784 args, info); 785 --processing_template_decl; 786 787 return t; 788} 789 790/* Returns the normalized constraints for the declaration D. */ 791 792static tree 793get_normalized_constraints_from_decl (tree d, bool diag = false) 794{ 795 tree tmpl; 796 tree decl; 797 798 /* For inherited constructors, consider the original declaration; 799 it has the correct template information attached. */ 800 d = strip_inheriting_ctors (d); 801 802 if (TREE_CODE (d) == TEMPLATE_DECL) 803 { 804 tmpl = d; 805 decl = DECL_TEMPLATE_RESULT (tmpl); 806 } 807 else 808 { 809 if (tree ti = DECL_TEMPLATE_INFO (d)) 810 tmpl = TI_TEMPLATE (ti); 811 else 812 tmpl = NULL_TREE; 813 decl = d; 814 } 815 816 /* Get the most general template for the declaration, and compute 817 arguments from that. This ensures that the arguments used for 818 normalization are always template parameters and not arguments 819 used for outer specializations. For example: 820 821 template<typename T> 822 struct S { 823 template<typename U> requires C<T, U> void f(U); 824 }; 825 826 S<int>::f(0); 827 828 When we normalize the requirements for S<int>::f, we want the 829 arguments to be {T, U}, not {int, U}. One reason for this is that 830 accepting the latter causes the template parameter level of U 831 to be reduced in a way that makes it overly difficult substitute 832 concrete arguments (i.e., eventually {int, int} during satisfaction. */ 833 if (tmpl) 834 { 835 if (DECL_LANG_SPECIFIC(tmpl) && !DECL_TEMPLATE_SPECIALIZATION (tmpl)) 836 tmpl = most_general_template (tmpl); 837 } 838 839 /* If we're not diagnosing errors, use cached constraints, if any. */ 840 if (!diag) 841 if (tree *p = hash_map_safe_get (normalized_map, tmpl)) 842 return *p; 843 844 push_nested_class_guard pncs (DECL_CONTEXT (d)); 845 846 tree args = generic_targs_for (tmpl); 847 tree ci = get_constraints (decl); 848 tree norm = get_normalized_constraints_from_info (ci, args, tmpl, diag); 849 850 if (!diag) 851 hash_map_safe_put<hm_ggc> (normalized_map, tmpl, norm); 852 853 return norm; 854} 855 856/* Returns the normal form of TMPL's definition. */ 857 858static tree 859normalize_concept_definition (tree tmpl, bool diag = false) 860{ 861 if (!diag) 862 if (tree *p = hash_map_safe_get (normalized_map, tmpl)) 863 return *p; 864 865 gcc_assert (concept_definition_p (tmpl)); 866 if (OVL_P (tmpl)) 867 tmpl = OVL_FIRST (tmpl); 868 gcc_assert (TREE_CODE (tmpl) == TEMPLATE_DECL); 869 tree args = generic_targs_for (tmpl); 870 tree def = get_concept_definition (DECL_TEMPLATE_RESULT (tmpl)); 871 ++processing_template_decl; 872 norm_info info (tmpl, diag ? tf_norm : tf_none); 873 tree norm = get_normalized_constraints (def, args, info); 874 --processing_template_decl; 875 876 if (!diag) 877 hash_map_safe_put<hm_ggc> (normalized_map, tmpl, norm); 878 879 return norm; 880} 881 882/* Returns the normal form of TMPL's requirements. */ 883 884static tree 885normalize_template_requirements (tree tmpl, bool diag = false) 886{ 887 return get_normalized_constraints_from_decl (tmpl, diag); 888} 889 890/* Returns the normal form of TMPL's requirements. */ 891 892static tree 893normalize_nontemplate_requirements (tree decl, bool diag = false) 894{ 895 return get_normalized_constraints_from_decl (decl, diag); 896} 897 898/* Normalize an EXPR as a constraint using ARGS. */ 899 900static tree 901normalize_constraint_expression (tree expr, tree args, bool diag = false) 902{ 903 if (!expr || expr == error_mark_node) 904 return expr; 905 ++processing_template_decl; 906 norm_info info (diag ? tf_norm : tf_none); 907 tree norm = get_normalized_constraints (expr, args, info); 908 --processing_template_decl; 909 return norm; 910} 911 912/* Normalize an EXPR as a constraint. */ 913 914static tree 915normalize_constraint_expression (tree expr, bool diag = false) 916{ 917 if (!expr || expr == error_mark_node) 918 return expr; 919 920 /* For concept checks, use the supplied template arguments as those used 921 for normalization. Otherwise, there are no template arguments. */ 922 tree args; 923 if (concept_check_p (expr)) 924 { 925 tree id = unpack_concept_check (expr); 926 args = TREE_OPERAND (id, 1); 927 } 928 else 929 args = NULL_TREE; 930 931 return normalize_constraint_expression (expr, args, diag); 932} 933 934/* 17.4.1.2p2. Two constraints are identical if they are formed 935 from the same expression and the targets of the parameter mapping 936 are equivalent. */ 937 938bool 939atomic_constraints_identical_p (tree t1, tree t2) 940{ 941 gcc_assert (TREE_CODE (t1) == ATOMIC_CONSTR); 942 gcc_assert (TREE_CODE (t2) == ATOMIC_CONSTR); 943 944 if (ATOMIC_CONSTR_EXPR (t1) != ATOMIC_CONSTR_EXPR (t2)) 945 return false; 946 947 if (!parameter_mapping_equivalent_p (t1, t2)) 948 return false; 949 950 return true; 951} 952 953/* True if T1 and T2 are equivalent, meaning they have the same syntactic 954 structure and all corresponding constraints are identical. */ 955 956bool 957constraints_equivalent_p (tree t1, tree t2) 958{ 959 gcc_assert (CONSTR_P (t1)); 960 gcc_assert (CONSTR_P (t2)); 961 962 if (TREE_CODE (t1) != TREE_CODE (t2)) 963 return false; 964 965 switch (TREE_CODE (t1)) 966 { 967 case CONJ_CONSTR: 968 case DISJ_CONSTR: 969 if (!constraints_equivalent_p (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0))) 970 return false; 971 if (!constraints_equivalent_p (TREE_OPERAND (t1, 1), TREE_OPERAND (t2, 1))) 972 return false; 973 break; 974 case ATOMIC_CONSTR: 975 if (!atomic_constraints_identical_p(t1, t2)) 976 return false; 977 break; 978 default: 979 gcc_unreachable (); 980 } 981 return true; 982} 983 984/* Compute the hash value for T. */ 985 986hashval_t 987hash_atomic_constraint (tree t) 988{ 989 gcc_assert (TREE_CODE (t) == ATOMIC_CONSTR); 990 991 /* Hash the identity of the expression. */ 992 hashval_t val = htab_hash_pointer (ATOMIC_CONSTR_EXPR (t)); 993 994 /* Hash the targets of the parameter map. */ 995 tree p = ATOMIC_CONSTR_MAP (t); 996 while (p) 997 { 998 val = iterative_hash_template_arg (TREE_PURPOSE (p), val); 999 p = TREE_CHAIN (p); 1000 } 1001 1002 return val; 1003} 1004 1005namespace inchash 1006{ 1007 1008static void 1009add_constraint (tree t, hash& h) 1010{ 1011 h.add_int(TREE_CODE (t)); 1012 switch (TREE_CODE (t)) 1013 { 1014 case CONJ_CONSTR: 1015 case DISJ_CONSTR: 1016 add_constraint (TREE_OPERAND (t, 0), h); 1017 add_constraint (TREE_OPERAND (t, 1), h); 1018 break; 1019 case ATOMIC_CONSTR: 1020 h.merge_hash (hash_atomic_constraint (t)); 1021 break; 1022 default: 1023 gcc_unreachable (); 1024 } 1025} 1026 1027} 1028 1029/* Computes a hash code for the constraint T. */ 1030 1031hashval_t 1032iterative_hash_constraint (tree t, hashval_t val) 1033{ 1034 gcc_assert (CONSTR_P (t)); 1035 inchash::hash h (val); 1036 inchash::add_constraint (t, h); 1037 return h.end (); 1038} 1039 1040// -------------------------------------------------------------------------- // 1041// Constraint Semantic Processing 1042// 1043// The following functions are called by the parser and substitution rules 1044// to create and evaluate constraint-related nodes. 1045 1046// The constraints associated with the current template parameters. 1047tree 1048current_template_constraints (void) 1049{ 1050 if (!current_template_parms) 1051 return NULL_TREE; 1052 tree tmpl_constr = TEMPLATE_PARMS_CONSTRAINTS (current_template_parms); 1053 return build_constraints (tmpl_constr, NULL_TREE); 1054} 1055 1056/* If the recently parsed TYPE declares or defines a template or 1057 template specialization, get its corresponding constraints from the 1058 current template parameters and bind them to TYPE's declaration. */ 1059 1060tree 1061associate_classtype_constraints (tree type) 1062{ 1063 if (!type || type == error_mark_node || !CLASS_TYPE_P (type)) 1064 return type; 1065 1066 /* An explicit class template specialization has no template parameters. */ 1067 if (!current_template_parms) 1068 return type; 1069 1070 if (CLASSTYPE_IS_TEMPLATE (type) || CLASSTYPE_TEMPLATE_SPECIALIZATION (type)) 1071 { 1072 tree decl = TYPE_STUB_DECL (type); 1073 tree ci = current_template_constraints (); 1074 1075 /* An implicitly instantiated member template declaration already 1076 has associated constraints. If it is defined outside of its 1077 class, then we need match these constraints against those of 1078 original declaration. */ 1079 if (tree orig_ci = get_constraints (decl)) 1080 { 1081 if (int extra_levels = (TMPL_PARMS_DEPTH (current_template_parms) 1082 - TMPL_ARGS_DEPTH (TYPE_TI_ARGS (type)))) 1083 { 1084 /* If there is a discrepancy between the current template depth 1085 and the template depth of the original declaration, then we 1086 must be redeclaring a class template as part of a friend 1087 declaration within another class template. Before matching 1088 constraints, we need to reduce the template parameter level 1089 within the current constraints via substitution. */ 1090 tree outer_gtargs = template_parms_to_args (current_template_parms); 1091 TREE_VEC_LENGTH (outer_gtargs) = extra_levels; 1092 ci = tsubst_constraint_info (ci, outer_gtargs, tf_none, NULL_TREE); 1093 } 1094 if (!equivalent_constraints (ci, orig_ci)) 1095 { 1096 error ("%qT does not match original declaration", type); 1097 tree tmpl = CLASSTYPE_TI_TEMPLATE (type); 1098 location_t loc = DECL_SOURCE_LOCATION (tmpl); 1099 inform (loc, "original template declaration here"); 1100 /* Fall through, so that we define the type anyway. */ 1101 } 1102 return type; 1103 } 1104 set_constraints (decl, ci); 1105 } 1106 return type; 1107} 1108 1109/* Create an empty constraint info block. */ 1110 1111static inline tree_constraint_info* 1112build_constraint_info () 1113{ 1114 return (tree_constraint_info *)make_node (CONSTRAINT_INFO); 1115} 1116 1117/* Build a constraint-info object that contains the associated constraints 1118 of a declaration. This also includes the declaration's template 1119 requirements (TREQS) and any trailing requirements for a function 1120 declarator (DREQS). Note that both TREQS and DREQS must be constraints. 1121 1122 If the declaration has neither template nor declaration requirements 1123 this returns NULL_TREE, indicating an unconstrained declaration. */ 1124 1125tree 1126build_constraints (tree tr, tree dr) 1127{ 1128 if (!tr && !dr) 1129 return NULL_TREE; 1130 1131 tree_constraint_info* ci = build_constraint_info (); 1132 ci->template_reqs = tr; 1133 ci->declarator_reqs = dr; 1134 ci->associated_constr = combine_constraint_expressions (tr, dr); 1135 1136 return (tree)ci; 1137} 1138 1139/* Add constraint RHS to the end of CONSTRAINT_INFO ci. */ 1140 1141tree 1142append_constraint (tree ci, tree rhs) 1143{ 1144 tree tr = ci ? CI_TEMPLATE_REQS (ci) : NULL_TREE; 1145 tree dr = ci ? CI_DECLARATOR_REQS (ci) : NULL_TREE; 1146 dr = combine_constraint_expressions (dr, rhs); 1147 if (ci) 1148 { 1149 CI_DECLARATOR_REQS (ci) = dr; 1150 tree ac = combine_constraint_expressions (tr, dr); 1151 CI_ASSOCIATED_CONSTRAINTS (ci) = ac; 1152 } 1153 else 1154 ci = build_constraints (tr, dr); 1155 return ci; 1156} 1157 1158/* A mapping from declarations to constraint information. */ 1159 1160static GTY ((cache)) decl_tree_cache_map *decl_constraints; 1161 1162/* Returns the template constraints of declaration T. If T is not 1163 constrained, return NULL_TREE. Note that T must be non-null. */ 1164 1165tree 1166get_constraints (const_tree t) 1167{ 1168 if (!flag_concepts) 1169 return NULL_TREE; 1170 if (!decl_constraints) 1171 return NULL_TREE; 1172 1173 gcc_assert (DECL_P (t)); 1174 if (TREE_CODE (t) == TEMPLATE_DECL) 1175 t = DECL_TEMPLATE_RESULT (t); 1176 tree* found = decl_constraints->get (CONST_CAST_TREE (t)); 1177 if (found) 1178 return *found; 1179 else 1180 return NULL_TREE; 1181} 1182 1183/* Associate the given constraint information CI with the declaration 1184 T. If T is a template, then the constraints are associated with 1185 its underlying declaration. Don't build associations if CI is 1186 NULL_TREE. */ 1187 1188void 1189set_constraints (tree t, tree ci) 1190{ 1191 if (!ci) 1192 return; 1193 gcc_assert (t && flag_concepts); 1194 if (TREE_CODE (t) == TEMPLATE_DECL) 1195 t = DECL_TEMPLATE_RESULT (t); 1196 bool found = hash_map_safe_put<hm_ggc> (decl_constraints, t, ci); 1197 gcc_assert (!found); 1198} 1199 1200/* Remove the associated constraints of the declaration T. */ 1201 1202void 1203remove_constraints (tree t) 1204{ 1205 gcc_assert (DECL_P (t)); 1206 if (TREE_CODE (t) == TEMPLATE_DECL) 1207 t = DECL_TEMPLATE_RESULT (t); 1208 1209 if (decl_constraints) 1210 decl_constraints->remove (t); 1211} 1212 1213/* If DECL is a friend, substitute into REQS to produce requirements suitable 1214 for declaration matching. */ 1215 1216tree 1217maybe_substitute_reqs_for (tree reqs, const_tree decl_) 1218{ 1219 if (reqs == NULL_TREE) 1220 return NULL_TREE; 1221 tree decl = CONST_CAST_TREE (decl_); 1222 tree result = STRIP_TEMPLATE (decl); 1223 if (DECL_FRIEND_P (result)) 1224 { 1225 tree tmpl = decl == result ? DECL_TI_TEMPLATE (result) : decl; 1226 tree gargs = generic_targs_for (tmpl); 1227 processing_template_decl_sentinel s; 1228 if (uses_template_parms (gargs)) 1229 ++processing_template_decl; 1230 reqs = tsubst_constraint (reqs, gargs, 1231 tf_warning_or_error, NULL_TREE); 1232 } 1233 return reqs; 1234} 1235 1236/* Returns the template-head requires clause for the template 1237 declaration T or NULL_TREE if none. */ 1238 1239tree 1240get_template_head_requirements (tree t) 1241{ 1242 tree ci = get_constraints (t); 1243 if (!ci) 1244 return NULL_TREE; 1245 return CI_TEMPLATE_REQS (ci); 1246} 1247 1248/* Returns the trailing requires clause of the declarator of 1249 a template declaration T or NULL_TREE if none. */ 1250 1251tree 1252get_trailing_function_requirements (tree t) 1253{ 1254 tree ci = get_constraints (t); 1255 if (!ci) 1256 return NULL_TREE; 1257 return CI_DECLARATOR_REQS (ci); 1258} 1259 1260/* Construct a sequence of template arguments by prepending 1261 ARG to REST. Either ARG or REST may be null. */ 1262static tree 1263build_concept_check_arguments (tree arg, tree rest) 1264{ 1265 gcc_assert (rest ? TREE_CODE (rest) == TREE_VEC : true); 1266 tree args; 1267 if (arg) 1268 { 1269 int n = rest ? TREE_VEC_LENGTH (rest) : 0; 1270 args = make_tree_vec (n + 1); 1271 TREE_VEC_ELT (args, 0) = arg; 1272 if (rest) 1273 for (int i = 0; i < n; ++i) 1274 TREE_VEC_ELT (args, i + 1) = TREE_VEC_ELT (rest, i); 1275 int def = rest ? GET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (rest) : 0; 1276 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (args, def + 1); 1277 } 1278 else 1279 { 1280 args = rest; 1281 } 1282 return args; 1283} 1284 1285/* Builds an id-expression of the form `C<Args...>()` where C is a function 1286 concept. */ 1287 1288static tree 1289build_function_check (tree tmpl, tree args, tsubst_flags_t /*complain*/) 1290{ 1291 if (TREE_CODE (tmpl) == TEMPLATE_DECL) 1292 { 1293 /* If we just got a template, wrap it in an overload so it looks like any 1294 other template-id. */ 1295 tmpl = ovl_make (tmpl); 1296 TREE_TYPE (tmpl) = boolean_type_node; 1297 } 1298 1299 /* Perform function concept resolution now so we always have a single 1300 function of the overload set (even if we started with only one; the 1301 resolution function converts template arguments). Note that we still 1302 wrap this in an overload set so we don't upset other parts of the 1303 compiler that expect template-ids referring to function concepts 1304 to have an overload set. */ 1305 tree info = resolve_function_concept_overload (tmpl, args); 1306 if (info == error_mark_node) 1307 return error_mark_node; 1308 if (!info) 1309 { 1310 error ("no matching concepts for %qE", tmpl); 1311 return error_mark_node; 1312 } 1313 args = TREE_PURPOSE (info); 1314 tmpl = DECL_TI_TEMPLATE (TREE_VALUE (info)); 1315 1316 /* Rebuild the singleton overload set; mark the type bool. */ 1317 tmpl = ovl_make (tmpl, NULL_TREE); 1318 TREE_TYPE (tmpl) = boolean_type_node; 1319 1320 /* Build the id-expression around the overload set. */ 1321 tree id = build2 (TEMPLATE_ID_EXPR, boolean_type_node, tmpl, args); 1322 1323 /* Finally, build the call expression around the overload. */ 1324 ++processing_template_decl; 1325 vec<tree, va_gc> *fargs = make_tree_vector (); 1326 tree call = build_min_nt_call_vec (id, fargs); 1327 TREE_TYPE (call) = boolean_type_node; 1328 release_tree_vector (fargs); 1329 --processing_template_decl; 1330 1331 return call; 1332} 1333 1334/* Builds an id-expression of the form `C<Args...>` where C is a variable 1335 concept. */ 1336 1337static tree 1338build_variable_check (tree tmpl, tree args, tsubst_flags_t complain) 1339{ 1340 gcc_assert (variable_concept_p (tmpl)); 1341 gcc_assert (TREE_CODE (tmpl) == TEMPLATE_DECL); 1342 tree parms = INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (tmpl)); 1343 args = coerce_template_parms (parms, args, tmpl, complain); 1344 if (args == error_mark_node) 1345 return error_mark_node; 1346 return build2 (TEMPLATE_ID_EXPR, boolean_type_node, tmpl, args); 1347} 1348 1349/* Builds an id-expression of the form `C<Args...>` where C is a standard 1350 concept. */ 1351 1352static tree 1353build_standard_check (tree tmpl, tree args, tsubst_flags_t complain) 1354{ 1355 gcc_assert (standard_concept_p (tmpl)); 1356 gcc_assert (TREE_CODE (tmpl) == TEMPLATE_DECL); 1357 tree parms = INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (tmpl)); 1358 args = coerce_template_parms (parms, args, tmpl, complain); 1359 if (args == error_mark_node) 1360 return error_mark_node; 1361 return build2 (TEMPLATE_ID_EXPR, boolean_type_node, tmpl, args); 1362} 1363 1364/* Construct an expression that checks TARGET using ARGS. */ 1365 1366tree 1367build_concept_check (tree target, tree args, tsubst_flags_t complain) 1368{ 1369 return build_concept_check (target, NULL_TREE, args, complain); 1370} 1371 1372/* Construct an expression that checks the concept given by DECL. If 1373 concept_definition_p (DECL) is false, this returns null. */ 1374 1375tree 1376build_concept_check (tree decl, tree arg, tree rest, tsubst_flags_t complain) 1377{ 1378 tree args = build_concept_check_arguments (arg, rest); 1379 1380 if (standard_concept_p (decl)) 1381 return build_standard_check (decl, args, complain); 1382 if (variable_concept_p (decl)) 1383 return build_variable_check (decl, args, complain); 1384 if (function_concept_p (decl)) 1385 return build_function_check (decl, args, complain); 1386 1387 return error_mark_node; 1388} 1389 1390/* Build a template-id that can participate in a concept check. */ 1391 1392static tree 1393build_concept_id (tree decl, tree args) 1394{ 1395 tree check = build_concept_check (decl, args, tf_warning_or_error); 1396 if (check == error_mark_node) 1397 return error_mark_node; 1398 return unpack_concept_check (check); 1399} 1400 1401/* Build a template-id that can participate in a concept check, preserving 1402 the source location of the original template-id. */ 1403 1404tree 1405build_concept_id (tree expr) 1406{ 1407 gcc_assert (TREE_CODE (expr) == TEMPLATE_ID_EXPR); 1408 tree id = build_concept_id (TREE_OPERAND (expr, 0), TREE_OPERAND (expr, 1)); 1409 protected_set_expr_location (id, cp_expr_location (expr)); 1410 return id; 1411} 1412 1413/* Build as template-id with a placeholder that can be used as a 1414 type constraint. 1415 1416 Note that this will diagnose errors if the initial concept check 1417 cannot be built. */ 1418 1419tree 1420build_type_constraint (tree decl, tree args, tsubst_flags_t complain) 1421{ 1422 tree wildcard = build_nt (WILDCARD_DECL); 1423 ++processing_template_decl; 1424 tree check = build_concept_check (decl, wildcard, args, complain); 1425 --processing_template_decl; 1426 if (check == error_mark_node) 1427 return error_mark_node; 1428 return unpack_concept_check (check); 1429} 1430 1431/* Returns a TYPE_DECL that contains sufficient information to 1432 build a template parameter of the same kind as PROTO and 1433 constrained by the concept declaration CNC. Note that PROTO 1434 is the first template parameter of CNC. 1435 1436 If specified, ARGS provides additional arguments to the 1437 constraint check. */ 1438tree 1439build_constrained_parameter (tree cnc, tree proto, tree args) 1440{ 1441 tree name = DECL_NAME (cnc); 1442 tree type = TREE_TYPE (proto); 1443 tree decl = build_decl (input_location, TYPE_DECL, name, type); 1444 CONSTRAINED_PARM_PROTOTYPE (decl) = proto; 1445 CONSTRAINED_PARM_CONCEPT (decl) = cnc; 1446 CONSTRAINED_PARM_EXTRA_ARGS (decl) = args; 1447 return decl; 1448} 1449 1450/* Create a constraint expression for the given DECL that evaluates the 1451 requirements specified by CONSTR, a TYPE_DECL that contains all the 1452 information necessary to build the requirements (see finish_concept_name 1453 for the layout of that TYPE_DECL). 1454 1455 Note that the constraints are neither reduced nor decomposed. That is 1456 done only after the requires clause has been parsed (or not). */ 1457 1458tree 1459finish_shorthand_constraint (tree decl, tree constr) 1460{ 1461 /* No requirements means no constraints. */ 1462 if (!constr) 1463 return NULL_TREE; 1464 1465 if (error_operand_p (constr)) 1466 return NULL_TREE; 1467 1468 tree proto = CONSTRAINED_PARM_PROTOTYPE (constr); 1469 tree con = CONSTRAINED_PARM_CONCEPT (constr); 1470 tree args = CONSTRAINED_PARM_EXTRA_ARGS (constr); 1471 1472 /* The TS lets use shorthand to constrain a pack of arguments, but the 1473 standard does not. 1474 1475 For the TS, consider: 1476 1477 template<C... Ts> struct s; 1478 1479 If C is variadic (and because Ts is a pack), we associate the 1480 constraint C<Ts...>. In all other cases, we associate 1481 the constraint (C<Ts> && ...). 1482 1483 The standard behavior cannot be overridden by -fconcepts-ts. */ 1484 bool variadic_concept_p = template_parameter_pack_p (proto); 1485 bool declared_pack_p = template_parameter_pack_p (decl); 1486 bool apply_to_each_p = (cxx_dialect >= cxx2a) ? true : !variadic_concept_p; 1487 1488 /* Get the argument and overload used for the requirement 1489 and adjust it if we're going to expand later. */ 1490 tree arg = template_parm_to_arg (decl); 1491 if (apply_to_each_p && declared_pack_p) 1492 arg = PACK_EXPANSION_PATTERN (TREE_VEC_ELT (ARGUMENT_PACK_ARGS (arg), 0)); 1493 1494 /* Build the concept constraint-expression. */ 1495 tree tmpl = DECL_TI_TEMPLATE (con); 1496 tree check = tmpl; 1497 if (TREE_CODE (con) == FUNCTION_DECL) 1498 check = ovl_make (tmpl); 1499 check = build_concept_check (check, arg, args, tf_warning_or_error); 1500 1501 /* Make the check a fold-expression if needed. */ 1502 if (apply_to_each_p && declared_pack_p) 1503 check = finish_left_unary_fold_expr (check, TRUTH_ANDIF_EXPR); 1504 1505 return check; 1506} 1507 1508/* Returns a conjunction of shorthand requirements for the template 1509 parameter list PARMS. Note that the requirements are stored in 1510 the TYPE of each tree node. */ 1511 1512tree 1513get_shorthand_constraints (tree parms) 1514{ 1515 tree result = NULL_TREE; 1516 parms = INNERMOST_TEMPLATE_PARMS (parms); 1517 for (int i = 0; i < TREE_VEC_LENGTH (parms); ++i) 1518 { 1519 tree parm = TREE_VEC_ELT (parms, i); 1520 tree constr = TEMPLATE_PARM_CONSTRAINTS (parm); 1521 result = combine_constraint_expressions (result, constr); 1522 } 1523 return result; 1524} 1525 1526/* Get the deduced wildcard from a DEDUCED placeholder. If the deduced 1527 wildcard is a pack, return the first argument of that pack. */ 1528 1529static tree 1530get_deduced_wildcard (tree wildcard) 1531{ 1532 if (ARGUMENT_PACK_P (wildcard)) 1533 wildcard = TREE_VEC_ELT (ARGUMENT_PACK_ARGS (wildcard), 0); 1534 gcc_assert (TREE_CODE (wildcard) == WILDCARD_DECL); 1535 return wildcard; 1536} 1537 1538/* Returns the prototype parameter for the nth deduced wildcard. */ 1539 1540static tree 1541get_introduction_prototype (tree wildcards, int index) 1542{ 1543 return TREE_TYPE (get_deduced_wildcard (TREE_VEC_ELT (wildcards, index))); 1544} 1545 1546/* Introduce a type template parameter. */ 1547 1548static tree 1549introduce_type_template_parameter (tree wildcard, bool& non_type_p) 1550{ 1551 non_type_p = false; 1552 return finish_template_type_parm (class_type_node, DECL_NAME (wildcard)); 1553} 1554 1555/* Introduce a template template parameter. */ 1556 1557static tree 1558introduce_template_template_parameter (tree wildcard, bool& non_type_p) 1559{ 1560 non_type_p = false; 1561 begin_template_parm_list (); 1562 current_template_parms = DECL_TEMPLATE_PARMS (TREE_TYPE (wildcard)); 1563 end_template_parm_list (); 1564 return finish_template_template_parm (class_type_node, DECL_NAME (wildcard)); 1565} 1566 1567/* Introduce a template non-type parameter. */ 1568 1569static tree 1570introduce_nontype_template_parameter (tree wildcard, bool& non_type_p) 1571{ 1572 non_type_p = true; 1573 tree parm = copy_decl (TREE_TYPE (wildcard)); 1574 DECL_NAME (parm) = DECL_NAME (wildcard); 1575 return parm; 1576} 1577 1578/* Introduce a single template parameter. */ 1579 1580static tree 1581build_introduced_template_parameter (tree wildcard, bool& non_type_p) 1582{ 1583 tree proto = TREE_TYPE (wildcard); 1584 1585 tree parm; 1586 if (TREE_CODE (proto) == TYPE_DECL) 1587 parm = introduce_type_template_parameter (wildcard, non_type_p); 1588 else if (TREE_CODE (proto) == TEMPLATE_DECL) 1589 parm = introduce_template_template_parameter (wildcard, non_type_p); 1590 else 1591 parm = introduce_nontype_template_parameter (wildcard, non_type_p); 1592 1593 /* Wrap in a TREE_LIST for process_template_parm. Note that introduced 1594 parameters do not retain the defaults from the source parameter. */ 1595 return build_tree_list (NULL_TREE, parm); 1596} 1597 1598/* Introduce a single template parameter. */ 1599 1600static tree 1601introduce_template_parameter (tree parms, tree wildcard) 1602{ 1603 gcc_assert (!ARGUMENT_PACK_P (wildcard)); 1604 tree proto = TREE_TYPE (wildcard); 1605 location_t loc = DECL_SOURCE_LOCATION (wildcard); 1606 1607 /* Diagnose the case where we have C{...Args}. */ 1608 if (WILDCARD_PACK_P (wildcard)) 1609 { 1610 tree id = DECL_NAME (wildcard); 1611 error_at (loc, "%qE cannot be introduced with an ellipsis %<...%>", id); 1612 inform (DECL_SOURCE_LOCATION (proto), "prototype declared here"); 1613 } 1614 1615 bool non_type_p; 1616 tree parm = build_introduced_template_parameter (wildcard, non_type_p); 1617 return process_template_parm (parms, loc, parm, non_type_p, false); 1618} 1619 1620/* Introduce a template parameter pack. */ 1621 1622static tree 1623introduce_template_parameter_pack (tree parms, tree wildcard) 1624{ 1625 bool non_type_p; 1626 tree parm = build_introduced_template_parameter (wildcard, non_type_p); 1627 location_t loc = DECL_SOURCE_LOCATION (wildcard); 1628 return process_template_parm (parms, loc, parm, non_type_p, true); 1629} 1630 1631/* Introduce the nth template parameter. */ 1632 1633static tree 1634introduce_template_parameter (tree parms, tree wildcards, int& index) 1635{ 1636 tree deduced = TREE_VEC_ELT (wildcards, index++); 1637 return introduce_template_parameter (parms, deduced); 1638} 1639 1640/* Introduce either a template parameter pack or a list of template 1641 parameters. */ 1642 1643static tree 1644introduce_template_parameters (tree parms, tree wildcards, int& index) 1645{ 1646 /* If the prototype was a parameter, we better have deduced an 1647 argument pack, and that argument must be the last deduced value 1648 in the wildcard vector. */ 1649 tree deduced = TREE_VEC_ELT (wildcards, index++); 1650 gcc_assert (ARGUMENT_PACK_P (deduced)); 1651 gcc_assert (index == TREE_VEC_LENGTH (wildcards)); 1652 1653 /* Introduce each element in the pack. */ 1654 tree args = ARGUMENT_PACK_ARGS (deduced); 1655 for (int i = 0; i < TREE_VEC_LENGTH (args); ++i) 1656 { 1657 tree arg = TREE_VEC_ELT (args, i); 1658 if (WILDCARD_PACK_P (arg)) 1659 parms = introduce_template_parameter_pack (parms, arg); 1660 else 1661 parms = introduce_template_parameter (parms, arg); 1662 } 1663 1664 return parms; 1665} 1666 1667/* Builds the template parameter list PARMS by chaining introduced 1668 parameters from the WILDCARD vector. INDEX is the position of 1669 the current parameter. */ 1670 1671static tree 1672process_introduction_parms (tree parms, tree wildcards, int& index) 1673{ 1674 tree proto = get_introduction_prototype (wildcards, index); 1675 if (template_parameter_pack_p (proto)) 1676 return introduce_template_parameters (parms, wildcards, index); 1677 else 1678 return introduce_template_parameter (parms, wildcards, index); 1679} 1680 1681/* Ensure that all template parameters have been introduced for the concept 1682 named in CHECK. If not, emit a diagnostic. 1683 1684 Note that implicitly introducing a parameter with a default argument 1685 creates a case where a parameter is declared, but unnamed, making 1686 it unusable in the definition. */ 1687 1688static bool 1689check_introduction_list (tree intros, tree check) 1690{ 1691 check = unpack_concept_check (check); 1692 tree tmpl = TREE_OPERAND (check, 0); 1693 if (OVL_P (tmpl)) 1694 tmpl = OVL_FIRST (tmpl); 1695 1696 tree parms = DECL_INNERMOST_TEMPLATE_PARMS (tmpl); 1697 if (TREE_VEC_LENGTH (intros) < TREE_VEC_LENGTH (parms)) 1698 { 1699 error_at (input_location, "all template parameters of %qD must " 1700 "be introduced", tmpl); 1701 return false; 1702 } 1703 1704 return true; 1705} 1706 1707/* Associates a constraint check to the current template based on the 1708 introduction parameters. INTRO_LIST must be a TREE_VEC of WILDCARD_DECLs 1709 containing a chained PARM_DECL which contains the identifier as well as 1710 the source location. TMPL_DECL is the decl for the concept being used. 1711 If we take a concept, C, this will form a check in the form of 1712 C<INTRO_LIST> filling in any extra arguments needed by the defaults 1713 deduced. 1714 1715 Returns NULL_TREE if no concept could be matched and error_mark_node if 1716 an error occurred when matching. */ 1717 1718tree 1719finish_template_introduction (tree tmpl_decl, 1720 tree intro_list, 1721 location_t intro_loc) 1722{ 1723 /* Build a concept check to deduce the actual parameters. */ 1724 tree expr = build_concept_check (tmpl_decl, intro_list, tf_none); 1725 if (expr == error_mark_node) 1726 { 1727 error_at (intro_loc, "cannot deduce template parameters from " 1728 "introduction list"); 1729 return error_mark_node; 1730 } 1731 1732 if (!check_introduction_list (intro_list, expr)) 1733 return error_mark_node; 1734 1735 tree parms = deduce_concept_introduction (expr); 1736 if (!parms) 1737 return NULL_TREE; 1738 1739 /* Build template parameter scope for introduction. */ 1740 tree parm_list = NULL_TREE; 1741 begin_template_parm_list (); 1742 int nargs = MIN (TREE_VEC_LENGTH (parms), TREE_VEC_LENGTH (intro_list)); 1743 for (int n = 0; n < nargs; ) 1744 parm_list = process_introduction_parms (parm_list, parms, n); 1745 parm_list = end_template_parm_list (parm_list); 1746 1747 /* Update the number of arguments to reflect the number of deduced 1748 template parameter introductions. */ 1749 nargs = TREE_VEC_LENGTH (parm_list); 1750 1751 /* Determine if any errors occurred during matching. */ 1752 for (int i = 0; i < TREE_VEC_LENGTH (parm_list); ++i) 1753 if (TREE_VALUE (TREE_VEC_ELT (parm_list, i)) == error_mark_node) 1754 { 1755 end_template_decl (); 1756 return error_mark_node; 1757 } 1758 1759 /* Build a concept check for our constraint. */ 1760 tree check_args = make_tree_vec (nargs); 1761 int n = 0; 1762 for (; n < TREE_VEC_LENGTH (parm_list); ++n) 1763 { 1764 tree parm = TREE_VEC_ELT (parm_list, n); 1765 TREE_VEC_ELT (check_args, n) = template_parm_to_arg (parm); 1766 } 1767 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (check_args, n); 1768 1769 /* If the template expects more parameters we should be able 1770 to use the defaults from our deduced concept. */ 1771 for (; n < TREE_VEC_LENGTH (parms); ++n) 1772 TREE_VEC_ELT (check_args, n) = TREE_VEC_ELT (parms, n); 1773 1774 /* Associate the constraint. */ 1775 tree check = build_concept_check (tmpl_decl, 1776 check_args, 1777 tf_warning_or_error); 1778 TEMPLATE_PARMS_CONSTRAINTS (current_template_parms) = check; 1779 1780 return parm_list; 1781} 1782 1783 1784/* Given the concept check T from a constrained-type-specifier, extract 1785 its TMPL and ARGS. FIXME why do we need two different forms of 1786 constrained-type-specifier? */ 1787 1788void 1789placeholder_extract_concept_and_args (tree t, tree &tmpl, tree &args) 1790{ 1791 if (concept_check_p (t)) 1792 { 1793 t = unpack_concept_check (t); 1794 tmpl = TREE_OPERAND (t, 0); 1795 if (TREE_CODE (tmpl) == OVERLOAD) 1796 tmpl = OVL_FIRST (tmpl); 1797 args = TREE_OPERAND (t, 1); 1798 return; 1799 } 1800 1801 if (TREE_CODE (t) == TYPE_DECL) 1802 { 1803 /* A constrained parameter. Build a constraint check 1804 based on the prototype parameter and then extract the 1805 arguments from that. */ 1806 tree proto = CONSTRAINED_PARM_PROTOTYPE (t); 1807 tree check = finish_shorthand_constraint (proto, t); 1808 placeholder_extract_concept_and_args (check, tmpl, args); 1809 return; 1810 } 1811} 1812 1813/* Returns true iff the placeholders C1 and C2 are equivalent. C1 1814 and C2 can be either TEMPLATE_TYPE_PARM or template-ids. */ 1815 1816bool 1817equivalent_placeholder_constraints (tree c1, tree c2) 1818{ 1819 if (c1 && TREE_CODE (c1) == TEMPLATE_TYPE_PARM) 1820 /* A constrained auto. */ 1821 c1 = PLACEHOLDER_TYPE_CONSTRAINTS (c1); 1822 if (c2 && TREE_CODE (c2) == TEMPLATE_TYPE_PARM) 1823 c2 = PLACEHOLDER_TYPE_CONSTRAINTS (c2); 1824 1825 if (c1 == c2) 1826 return true; 1827 if (!c1 || !c2) 1828 return false; 1829 if (c1 == error_mark_node || c2 == error_mark_node) 1830 /* We get here during satisfaction; when a deduction constraint 1831 fails, substitution can produce an error_mark_node for the 1832 placeholder constraints. */ 1833 return false; 1834 1835 tree t1, t2, a1, a2; 1836 placeholder_extract_concept_and_args (c1, t1, a1); 1837 placeholder_extract_concept_and_args (c2, t2, a2); 1838 1839 if (t1 != t2) 1840 return false; 1841 1842 int len1 = TREE_VEC_LENGTH (a1); 1843 int len2 = TREE_VEC_LENGTH (a2); 1844 if (len1 != len2) 1845 return false; 1846 1847 /* Skip the first argument so we don't infinitely recurse. 1848 Also, they may differ in template parameter index. */ 1849 for (int i = 1; i < len1; ++i) 1850 { 1851 tree t1 = TREE_VEC_ELT (a1, i); 1852 tree t2 = TREE_VEC_ELT (a2, i); 1853 if (!template_args_equal (t1, t2)) 1854 return false; 1855 } 1856 return true; 1857} 1858 1859/* Return a hash value for the placeholder ATOMIC_CONSTR C. */ 1860 1861hashval_t 1862hash_placeholder_constraint (tree c) 1863{ 1864 tree t, a; 1865 placeholder_extract_concept_and_args (c, t, a); 1866 1867 /* Like hash_tmpl_and_args, but skip the first argument. */ 1868 hashval_t val = iterative_hash_object (DECL_UID (t), 0); 1869 1870 for (int i = TREE_VEC_LENGTH (a)-1; i > 0; --i) 1871 val = iterative_hash_template_arg (TREE_VEC_ELT (a, i), val); 1872 1873 return val; 1874} 1875 1876/* Substitute through the simple requirement. */ 1877 1878static tree 1879tsubst_valid_expression_requirement (tree t, tree args, subst_info info) 1880{ 1881 tree r = tsubst_expr (t, args, info.complain, info.in_decl, false); 1882 if (convert_to_void (r, ICV_STATEMENT, info.complain) == error_mark_node) 1883 return error_mark_node; 1884 return r; 1885} 1886 1887 1888/* Substitute through the simple requirement. */ 1889 1890static tree 1891tsubst_simple_requirement (tree t, tree args, subst_info info) 1892{ 1893 tree t0 = TREE_OPERAND (t, 0); 1894 tree expr = tsubst_valid_expression_requirement (t0, args, info); 1895 if (expr == error_mark_node) 1896 return error_mark_node; 1897 return finish_simple_requirement (EXPR_LOCATION (t), expr); 1898} 1899 1900/* Substitute through the type requirement. */ 1901 1902static tree 1903tsubst_type_requirement (tree t, tree args, subst_info info) 1904{ 1905 tree t0 = TREE_OPERAND (t, 0); 1906 tree type = tsubst (t0, args, info.complain, info.in_decl); 1907 if (type == error_mark_node) 1908 return error_mark_node; 1909 return finish_type_requirement (EXPR_LOCATION (t), type); 1910} 1911 1912/* True if TYPE can be deduced from EXPR. */ 1913 1914static bool 1915type_deducible_p (tree expr, tree type, tree placeholder, tree args, 1916 subst_info info) 1917{ 1918 /* Make sure deduction is performed against ( EXPR ), so that 1919 references are preserved in the result. */ 1920 expr = force_paren_expr_uneval (expr); 1921 1922 /* Replace the constraints with the instantiated constraints. This 1923 substitutes args into any template parameters in the trailing 1924 result type. */ 1925 tree saved_constr = PLACEHOLDER_TYPE_CONSTRAINTS (placeholder); 1926 tree subst_constr 1927 = tsubst_constraint (saved_constr, 1928 args, 1929 info.complain | tf_partial, 1930 info.in_decl); 1931 1932 if (subst_constr == error_mark_node) 1933 return false; 1934 1935 PLACEHOLDER_TYPE_CONSTRAINTS (placeholder) = subst_constr; 1936 1937 /* Temporarily unlink the canonical type. */ 1938 tree saved_type = TYPE_CANONICAL (placeholder); 1939 TYPE_CANONICAL (placeholder) = NULL_TREE; 1940 1941 tree deduced_type 1942 = do_auto_deduction (type, 1943 expr, 1944 placeholder, 1945 info.complain, 1946 adc_requirement); 1947 1948 PLACEHOLDER_TYPE_CONSTRAINTS (placeholder) = saved_constr; 1949 TYPE_CANONICAL (placeholder) = saved_type; 1950 1951 if (deduced_type == error_mark_node) 1952 return false; 1953 1954 return true; 1955} 1956 1957/* True if EXPR can not be converted to TYPE. */ 1958 1959static bool 1960expression_convertible_p (tree expr, tree type, subst_info info) 1961{ 1962 tree conv = 1963 perform_direct_initialization_if_possible (type, expr, false, 1964 info.complain); 1965 if (conv == error_mark_node) 1966 return false; 1967 if (conv == NULL_TREE) 1968 { 1969 if (info.complain & tf_error) 1970 { 1971 location_t loc = EXPR_LOC_OR_LOC (expr, input_location); 1972 error_at (loc, "cannot convert %qE to %qT", expr, type); 1973 } 1974 return false; 1975 } 1976 return true; 1977} 1978 1979 1980/* Substitute through the compound requirement. */ 1981 1982static tree 1983tsubst_compound_requirement (tree t, tree args, subst_info info) 1984{ 1985 tree t0 = TREE_OPERAND (t, 0); 1986 tree t1 = TREE_OPERAND (t, 1); 1987 tree expr = tsubst_valid_expression_requirement (t0, args, info); 1988 if (expr == error_mark_node) 1989 return error_mark_node; 1990 1991 /* Check the noexcept condition. */ 1992 bool noexcept_p = COMPOUND_REQ_NOEXCEPT_P (t); 1993 if (noexcept_p && !expr_noexcept_p (expr, tf_none)) 1994 return error_mark_node; 1995 1996 /* Substitute through the type expression, if any. */ 1997 tree type = tsubst (t1, args, info.complain, info.in_decl); 1998 if (type == error_mark_node) 1999 return error_mark_node; 2000 2001 subst_info quiet (tf_none, info.in_decl); 2002 2003 /* Check expression against the result type. */ 2004 if (type) 2005 { 2006 if (tree placeholder = type_uses_auto (type)) 2007 { 2008 if (!type_deducible_p (expr, type, placeholder, args, quiet)) 2009 return error_mark_node; 2010 } 2011 else if (!expression_convertible_p (expr, type, quiet)) 2012 return error_mark_node; 2013 } 2014 2015 return finish_compound_requirement (EXPR_LOCATION (t), 2016 expr, type, noexcept_p); 2017} 2018 2019static tree 2020tsubst_nested_requirement (tree t, tree args, subst_info info) 2021{ 2022 /* Ensure that we're in an evaluation context prior to satisfaction. */ 2023 tree norm = TREE_VALUE (TREE_TYPE (t)); 2024 tree result = satisfy_constraint (norm, args, info); 2025 if (result == error_mark_node && info.quiet ()) 2026 { 2027 subst_info noisy (tf_warning_or_error, info.in_decl); 2028 satisfy_constraint (norm, args, noisy); 2029 } 2030 if (result != boolean_true_node) 2031 return error_mark_node; 2032 return result; 2033} 2034 2035/* Substitute ARGS into the requirement T. */ 2036 2037static tree 2038tsubst_requirement (tree t, tree args, subst_info info) 2039{ 2040 iloc_sentinel loc_s (cp_expr_location (t)); 2041 switch (TREE_CODE (t)) 2042 { 2043 case SIMPLE_REQ: 2044 return tsubst_simple_requirement (t, args, info); 2045 case TYPE_REQ: 2046 return tsubst_type_requirement (t, args, info); 2047 case COMPOUND_REQ: 2048 return tsubst_compound_requirement (t, args, info); 2049 case NESTED_REQ: 2050 return tsubst_nested_requirement (t, args, info); 2051 default: 2052 break; 2053 } 2054 gcc_unreachable (); 2055} 2056 2057/* Substitute ARGS into the list of requirements T. Note that 2058 substitution failures here result in ill-formed programs. */ 2059 2060static tree 2061tsubst_requirement_body (tree t, tree args, subst_info info) 2062{ 2063 tree result = NULL_TREE; 2064 while (t) 2065 { 2066 tree req = tsubst_requirement (TREE_VALUE (t), args, info); 2067 if (req == error_mark_node) 2068 return error_mark_node; 2069 result = tree_cons (NULL_TREE, req, result); 2070 t = TREE_CHAIN (t); 2071 } 2072 return nreverse (result); 2073} 2074 2075static tree 2076declare_constraint_vars (tree parms, tree vars) 2077{ 2078 tree s = vars; 2079 for (tree t = parms; t; t = DECL_CHAIN (t)) 2080 { 2081 if (DECL_PACK_P (t)) 2082 { 2083 tree pack = extract_fnparm_pack (t, &s); 2084 register_local_specialization (pack, t); 2085 } 2086 else 2087 { 2088 register_local_specialization (s, t); 2089 s = DECL_CHAIN (s); 2090 } 2091 } 2092 return vars; 2093} 2094 2095/* Substitute through as if checking function parameter types. This 2096 will diagnose common parameter type errors. Returns error_mark_node 2097 if an error occurred. */ 2098 2099static tree 2100check_constaint_variables (tree t, tree args, subst_info info) 2101{ 2102 tree types = NULL_TREE; 2103 tree p = t; 2104 while (p && !VOID_TYPE_P (p)) 2105 { 2106 types = tree_cons (NULL_TREE, TREE_TYPE (p), types); 2107 p = TREE_CHAIN (p); 2108 } 2109 types = chainon (nreverse (types), void_list_node); 2110 return tsubst_function_parms (types, args, info.complain, info.in_decl); 2111} 2112 2113/* A subroutine of tsubst_parameterized_constraint. Substitute ARGS 2114 into the parameter list T, producing a sequence of constraint 2115 variables, declared in the current scope. 2116 2117 Note that the caller must establish a local specialization stack 2118 prior to calling this function since this substitution will 2119 declare the substituted parameters. */ 2120 2121static tree 2122tsubst_constraint_variables (tree t, tree args, subst_info info) 2123{ 2124 /* Perform a trial substitution to check for type errors. */ 2125 tree parms = check_constaint_variables (t, args, info); 2126 if (parms == error_mark_node) 2127 return error_mark_node; 2128 2129 /* Clear cp_unevaluated_operand across tsubst so that we get a proper chain 2130 of PARM_DECLs. */ 2131 int saved_unevaluated_operand = cp_unevaluated_operand; 2132 cp_unevaluated_operand = 0; 2133 tree vars = tsubst (t, args, info.complain, info.in_decl); 2134 cp_unevaluated_operand = saved_unevaluated_operand; 2135 if (vars == error_mark_node) 2136 return error_mark_node; 2137 return declare_constraint_vars (t, vars); 2138} 2139 2140/* Substitute ARGS into the requires-expression T. [8.4.7]p6. The 2141 substitution of template arguments into a requires-expression 2142 may result in the formation of invalid types or expressions 2143 in its requirements ... In such cases, the expression evaluates 2144 to false; it does not cause the program to be ill-formed. 2145 2146 However, there are cases where substitution must produce a 2147 new requires-expression, that is not a template constraint. 2148 For example: 2149 2150 template<typename T> 2151 class X { 2152 template<typename U> 2153 static constexpr bool var = requires (U u) { T::fn(u); }; 2154 }; 2155 2156 In the instantiation of X<Y> (assuming Y defines fn), then the 2157 instantiated requires-expression would include Y::fn(u). If any 2158 substitution in the requires-expression fails, we can immediately 2159 fold the expression to false, as would be the case e.g., when 2160 instantiation X<int>. */ 2161 2162tree 2163tsubst_requires_expr (tree t, tree args, 2164 tsubst_flags_t complain, tree in_decl) 2165{ 2166 local_specialization_stack stack (lss_copy); 2167 2168 subst_info info (complain, in_decl); 2169 2170 /* A requires-expression is an unevaluated context. */ 2171 cp_unevaluated u; 2172 2173 tree parms = TREE_OPERAND (t, 0); 2174 if (parms) 2175 { 2176 parms = tsubst_constraint_variables (parms, args, info); 2177 if (parms == error_mark_node) 2178 return boolean_false_node; 2179 } 2180 2181 tree reqs = TREE_OPERAND (t, 1); 2182 reqs = tsubst_requirement_body (reqs, args, info); 2183 if (reqs == error_mark_node) 2184 return boolean_false_node; 2185 2186 if (processing_template_decl) 2187 return finish_requires_expr (cp_expr_location (t), parms, reqs); 2188 2189 return boolean_true_node; 2190} 2191 2192/* Substitute ARGS into the constraint information CI, producing a new 2193 constraint record. */ 2194 2195tree 2196tsubst_constraint_info (tree t, tree args, 2197 tsubst_flags_t complain, tree in_decl) 2198{ 2199 if (!t || t == error_mark_node || !check_constraint_info (t)) 2200 return NULL_TREE; 2201 2202 tree tr = tsubst_constraint (CI_TEMPLATE_REQS (t), args, complain, in_decl); 2203 tree dr = tsubst_constraint (CI_DECLARATOR_REQS (t), args, complain, in_decl); 2204 return build_constraints (tr, dr); 2205} 2206 2207/* Substitute through a parameter mapping, in order to get the actual 2208 arguments used to instantiate an atomic constraint. This may fail 2209 if the substitution into arguments produces something ill-formed. */ 2210 2211static tree 2212tsubst_parameter_mapping (tree map, tree args, subst_info info) 2213{ 2214 if (!map) 2215 return NULL_TREE; 2216 2217 tsubst_flags_t complain = info.complain; 2218 tree in_decl = info.in_decl; 2219 2220 tree result = NULL_TREE; 2221 for (tree p = map; p; p = TREE_CHAIN (p)) 2222 { 2223 if (p == error_mark_node) 2224 return error_mark_node; 2225 tree parm = TREE_VALUE (p); 2226 tree arg = TREE_PURPOSE (p); 2227 tree new_arg = NULL_TREE; 2228 if (TYPE_P (arg)) 2229 { 2230 /* If a template parameter is declared with a placeholder, we can 2231 get those in the argument list if decltype is applied to the 2232 placeholder. For example: 2233 2234 template<auto T> 2235 requires C<decltype(T)> 2236 void f() { } 2237 2238 The normalized argument for C will be an auto type, so we'll 2239 need to deduce the actual argument from the corresponding 2240 initializer (whatever argument is provided for T), and use 2241 that result in the instantiated parameter mapping. */ 2242 if (tree auto_node = type_uses_auto (arg)) 2243 { 2244 int level; 2245 int index; 2246 template_parm_level_and_index (parm, &level, &index); 2247 tree init = TMPL_ARG (args, level, index); 2248 new_arg = do_auto_deduction (arg, init, auto_node, 2249 complain, adc_variable_type, 2250 make_tree_vec (0)); 2251 } 2252 } 2253 else if (ARGUMENT_PACK_P (arg)) 2254 new_arg = tsubst_argument_pack (arg, args, complain, in_decl); 2255 if (!new_arg) 2256 { 2257 new_arg = tsubst_template_arg (arg, args, complain, in_decl); 2258 if (TYPE_P (new_arg)) 2259 new_arg = canonicalize_type_argument (new_arg, complain); 2260 } 2261 if (new_arg == error_mark_node) 2262 return error_mark_node; 2263 2264 result = tree_cons (new_arg, parm, result); 2265 } 2266 return nreverse (result); 2267} 2268 2269tree 2270tsubst_parameter_mapping (tree map, tree args, tsubst_flags_t complain, tree in_decl) 2271{ 2272 return tsubst_parameter_mapping (map, args, subst_info (complain, in_decl)); 2273} 2274 2275/*--------------------------------------------------------------------------- 2276 Constraint satisfaction 2277---------------------------------------------------------------------------*/ 2278 2279/* Hash functions for satisfaction entries. */ 2280 2281struct GTY((for_user)) sat_entry 2282{ 2283 tree constr; 2284 tree args; 2285 tree result; 2286}; 2287 2288struct sat_hasher : ggc_ptr_hash<sat_entry> 2289{ 2290 static hashval_t hash (sat_entry *e) 2291 { 2292 hashval_t value = hash_atomic_constraint (e->constr); 2293 return iterative_hash_template_arg (e->args, value); 2294 } 2295 2296 static bool equal (sat_entry *e1, sat_entry *e2) 2297 { 2298 if (!atomic_constraints_identical_p (e1->constr, e2->constr)) 2299 return false; 2300 return template_args_equal (e1->args, e2->args); 2301 } 2302}; 2303 2304/* Cache the result of satisfy_atom. */ 2305static GTY((deletable)) hash_table<sat_hasher> *sat_cache; 2306 2307/* Cache the result of constraint_satisfaction_value. */ 2308static GTY((deletable)) hash_map<tree, tree> *decl_satisfied_cache; 2309 2310static tree 2311get_satisfaction (tree constr, tree args) 2312{ 2313 if (!sat_cache) 2314 return NULL_TREE; 2315 sat_entry elt = { constr, args, NULL_TREE }; 2316 sat_entry* found = sat_cache->find (&elt); 2317 if (found) 2318 return found->result; 2319 else 2320 return NULL_TREE; 2321} 2322 2323static void 2324save_satisfaction (tree constr, tree args, tree result) 2325{ 2326 if (!sat_cache) 2327 sat_cache = hash_table<sat_hasher>::create_ggc (31); 2328 sat_entry elt = {constr, args, result}; 2329 sat_entry** slot = sat_cache->find_slot (&elt, INSERT); 2330 sat_entry* entry = ggc_alloc<sat_entry> (); 2331 *entry = elt; 2332 *slot = entry; 2333} 2334 2335void 2336clear_satisfaction_cache () 2337{ 2338 if (sat_cache) 2339 sat_cache->empty (); 2340 if (decl_satisfied_cache) 2341 decl_satisfied_cache->empty (); 2342} 2343 2344/* A tool to help manage satisfaction caching in satisfy_constraint_r. 2345 Note the cache is only used when not diagnosing errors. */ 2346 2347struct satisfaction_cache 2348{ 2349 satisfaction_cache (tree constr, tree args, tsubst_flags_t complain) 2350 : constr(constr), args(args), complain(complain) 2351 { } 2352 2353 tree get () 2354 { 2355 if (complain == tf_none) 2356 return get_satisfaction (constr, args); 2357 return NULL_TREE; 2358 } 2359 2360 tree save (tree result) 2361 { 2362 if (complain == tf_none) 2363 save_satisfaction (constr, args, result); 2364 return result; 2365 } 2366 2367 tree constr; 2368 tree args; 2369 tsubst_flags_t complain; 2370}; 2371 2372static int satisfying_constraint = 0; 2373 2374/* Returns true if we are currently satisfying a constraint. 2375 2376 This is used to guard against recursive calls to evaluate_concept_check 2377 during template argument substitution. 2378 2379 TODO: Do we need this now that we fully normalize prior to evaluation? 2380 I think not. */ 2381 2382bool 2383satisfying_constraint_p () 2384{ 2385 return satisfying_constraint; 2386} 2387 2388/* Substitute ARGS into constraint-expression T during instantiation of 2389 a member of a class template. */ 2390 2391tree 2392tsubst_constraint (tree t, tree args, tsubst_flags_t complain, tree in_decl) 2393{ 2394 /* We also don't want to evaluate concept-checks when substituting the 2395 constraint-expressions of a declaration. */ 2396 processing_constraint_expression_sentinel s; 2397 tree expr = tsubst_expr (t, args, complain, in_decl, false); 2398 return expr; 2399} 2400 2401static tree satisfy_constraint_r (tree, tree, subst_info info); 2402 2403/* Compute the satisfaction of a conjunction. */ 2404 2405static tree 2406satisfy_conjunction (tree t, tree args, subst_info info) 2407{ 2408 tree lhs = satisfy_constraint_r (TREE_OPERAND (t, 0), args, info); 2409 if (lhs == error_mark_node || lhs == boolean_false_node) 2410 return lhs; 2411 return satisfy_constraint_r (TREE_OPERAND (t, 1), args, info); 2412} 2413 2414/* The current depth at which we're replaying an error during recursive 2415 diagnosis of a constraint satisfaction failure. */ 2416 2417static int current_constraint_diagnosis_depth; 2418 2419/* Whether CURRENT_CONSTRAINT_DIAGNOSIS_DEPTH has ever exceeded 2420 CONCEPTS_DIAGNOSTICS_MAX_DEPTH during recursive diagnosis of a constraint 2421 satisfaction error. */ 2422 2423static bool concepts_diagnostics_max_depth_exceeded_p; 2424 2425/* Recursive subroutine of collect_operands_of_disjunction. T is a normalized 2426 subexpression of a constraint (composed of CONJ_CONSTRs and DISJ_CONSTRs) 2427 and E is the corresponding unnormalized subexpression (composed of 2428 TRUTH_ANDIF_EXPRs and TRUTH_ORIF_EXPRs). */ 2429 2430static void 2431collect_operands_of_disjunction_r (tree t, tree e, 2432 auto_vec<tree_pair> *operands) 2433{ 2434 if (TREE_CODE (e) == TRUTH_ORIF_EXPR) 2435 { 2436 collect_operands_of_disjunction_r (TREE_OPERAND (t, 0), 2437 TREE_OPERAND (e, 0), operands); 2438 collect_operands_of_disjunction_r (TREE_OPERAND (t, 1), 2439 TREE_OPERAND (e, 1), operands); 2440 } 2441 else 2442 { 2443 tree_pair p = std::make_pair (t, e); 2444 operands->safe_push (p); 2445 } 2446} 2447 2448/* Recursively collect the normalized and unnormalized operands of the 2449 disjunction T and append them to OPERANDS in order. */ 2450 2451static void 2452collect_operands_of_disjunction (tree t, auto_vec<tree_pair> *operands) 2453{ 2454 collect_operands_of_disjunction_r (t, CONSTR_EXPR (t), operands); 2455} 2456 2457/* Compute the satisfaction of a disjunction. */ 2458 2459static tree 2460satisfy_disjunction (tree t, tree args, subst_info info) 2461{ 2462 /* Evaluate the operands quietly. */ 2463 subst_info quiet (tf_none, NULL_TREE); 2464 2465 /* Register the constraint for diagnostics, if needed. */ 2466 diagnosing_failed_constraint failure (t, args, info.noisy ()); 2467 2468 tree lhs = satisfy_constraint_r (TREE_OPERAND (t, 0), args, quiet); 2469 if (lhs == boolean_true_node) 2470 return boolean_true_node; 2471 tree rhs = satisfy_constraint_r (TREE_OPERAND (t, 1), args, quiet); 2472 if (rhs != boolean_true_node && info.noisy ()) 2473 { 2474 cp_expr disj_expr = CONSTR_EXPR (t); 2475 inform (disj_expr.get_location (), 2476 "no operand of the disjunction is satisfied"); 2477 if (diagnosing_failed_constraint::replay_errors_p ()) 2478 { 2479 /* Replay the error in each branch of the disjunction. */ 2480 auto_vec<tree_pair> operands; 2481 collect_operands_of_disjunction (t, &operands); 2482 for (unsigned i = 0; i < operands.length (); i++) 2483 { 2484 tree norm_op = operands[i].first; 2485 tree op = operands[i].second; 2486 location_t loc = make_location (cp_expr_location (op), 2487 disj_expr.get_start (), 2488 disj_expr.get_finish ()); 2489 inform (loc, "the operand %qE is unsatisfied because", op); 2490 satisfy_constraint_r (norm_op, args, info); 2491 } 2492 } 2493 } 2494 return rhs; 2495} 2496 2497/* Ensures that T is a truth value and not (accidentally, as sometimes 2498 happens) an integer value. */ 2499 2500tree 2501satisfaction_value (tree t) 2502{ 2503 if (t == error_mark_node || t == boolean_true_node || t == boolean_false_node) 2504 return t; 2505 gcc_assert (TREE_CODE (t) == INTEGER_CST); 2506 if (integer_onep (t)) 2507 return boolean_true_node; 2508 if (integer_zerop (t)) 2509 return boolean_false_node; 2510 2511 /* Anything else should be invalid. */ 2512 gcc_assert (false); 2513} 2514 2515/* Build a new template argument list with template arguments corresponding 2516 to the parameters used in an atomic constraint. */ 2517 2518tree 2519get_mapped_args (tree map) 2520{ 2521 /* No map, no arguments. */ 2522 if (!map) 2523 return NULL_TREE; 2524 2525 /* Find the mapped parameter with the highest level. */ 2526 int count = 0; 2527 for (tree p = map; p; p = TREE_CHAIN (p)) 2528 { 2529 int level; 2530 int index; 2531 template_parm_level_and_index (TREE_VALUE (p), &level, &index); 2532 if (level > count) 2533 count = level; 2534 } 2535 2536 /* Place each argument at its corresponding position in the argument 2537 list. Note that the list will be sparse (not all arguments supplied), 2538 but instantiation is guaranteed to only use the parameters in the 2539 mapping, so null arguments would never be used. */ 2540 auto_vec< vec<tree> > lists (count); 2541 lists.quick_grow_cleared (count); 2542 for (tree p = map; p; p = TREE_CHAIN (p)) 2543 { 2544 int level; 2545 int index; 2546 template_parm_level_and_index (TREE_VALUE (p), &level, &index); 2547 2548 /* Insert the argument into its corresponding position. */ 2549 vec<tree> &list = lists[level - 1]; 2550 if (index >= (int)list.length ()) 2551 list.safe_grow_cleared (index + 1); 2552 list[index] = TREE_PURPOSE (p); 2553 } 2554 2555 /* Build the new argument list. */ 2556 tree args = make_tree_vec (lists.length ()); 2557 for (unsigned i = 0; i != lists.length (); ++i) 2558 { 2559 vec<tree> &list = lists[i]; 2560 tree level = make_tree_vec (list.length ()); 2561 for (unsigned j = 0; j < list.length(); ++j) 2562 TREE_VEC_ELT (level, j) = list[j]; 2563 SET_TMPL_ARGS_LEVEL (args, i + 1, level); 2564 list.release (); 2565 } 2566 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (args, 0); 2567 2568 return args; 2569} 2570 2571static void diagnose_atomic_constraint (tree, tree, tree, subst_info); 2572 2573/* Compute the satisfaction of an atomic constraint. */ 2574 2575static tree 2576satisfy_atom (tree t, tree args, subst_info info) 2577{ 2578 satisfaction_cache cache (t, args, info.complain); 2579 if (tree r = cache.get ()) 2580 return r; 2581 2582 /* Perform substitution quietly. */ 2583 subst_info quiet (tf_none, NULL_TREE); 2584 2585 /* In case there is a diagnostic, we want to establish the context 2586 prior to printing errors. If no errors occur, this context is 2587 removed before returning. */ 2588 diagnosing_failed_constraint failure (t, args, info.noisy ()); 2589 2590 /* Instantiate the parameter mapping. */ 2591 tree map = tsubst_parameter_mapping (ATOMIC_CONSTR_MAP (t), args, quiet); 2592 if (map == error_mark_node) 2593 { 2594 /* If instantiation of the parameter mapping fails, the program 2595 is ill-formed. */ 2596 if (info.noisy()) 2597 tsubst_parameter_mapping (ATOMIC_CONSTR_MAP (t), args, info); 2598 return cache.save (boolean_false_node); 2599 } 2600 2601 /* Rebuild the argument vector from the parameter mapping. */ 2602 args = get_mapped_args (map); 2603 2604 /* Apply the parameter mapping (i.e., just substitute). */ 2605 tree expr = ATOMIC_CONSTR_EXPR (t); 2606 tree result = tsubst_expr (expr, args, quiet.complain, quiet.in_decl, false); 2607 if (result == error_mark_node) 2608 { 2609 /* If substitution results in an invalid type or expression, the constraint 2610 is not satisfied. Replay the substitution. */ 2611 if (info.noisy ()) 2612 tsubst_expr (expr, args, info.complain, info.in_decl, false); 2613 return cache.save (boolean_false_node); 2614 } 2615 2616 /* [17.4.1.2] ... lvalue-to-rvalue conversion is performed as necessary, 2617 and EXPR shall be a constant expression of type bool. */ 2618 result = force_rvalue (result, info.complain); 2619 if (result == error_mark_node) 2620 return cache.save (error_mark_node); 2621 if (!same_type_p (TREE_TYPE (result), boolean_type_node)) 2622 { 2623 if (info.noisy ()) 2624 diagnose_atomic_constraint (t, map, result, info); 2625 return cache.save (error_mark_node); 2626 } 2627 2628 /* Compute the value of the constraint. */ 2629 if (info.noisy ()) 2630 result = cxx_constant_value (result); 2631 else 2632 { 2633 result = maybe_constant_value (result, NULL_TREE, 2634 /*manifestly_const_eval=*/true); 2635 if (!TREE_CONSTANT (result)) 2636 result = error_mark_node; 2637 } 2638 result = satisfaction_value (result); 2639 if (result == boolean_false_node && info.noisy ()) 2640 diagnose_atomic_constraint (t, map, result, info); 2641 2642 return cache.save (result); 2643} 2644 2645/* Determine if the normalized constraint T is satisfied. 2646 Returns boolean_true_node if the expression/constraint is 2647 satisfied, boolean_false_node if not, and error_mark_node 2648 if the there was an error evaluating the constraint. 2649 2650 The parameter mapping of atomic constraints is simply the 2651 set of template arguments that will be substituted into 2652 the expression, regardless of template parameters appearing 2653 withing. Whether a template argument is used in the atomic 2654 constraint only matters for subsumption. */ 2655 2656static tree 2657satisfy_constraint_r (tree t, tree args, subst_info info) 2658{ 2659 if (t == error_mark_node) 2660 return error_mark_node; 2661 2662 switch (TREE_CODE (t)) 2663 { 2664 case CONJ_CONSTR: 2665 return satisfy_conjunction (t, args, info); 2666 case DISJ_CONSTR: 2667 return satisfy_disjunction (t, args, info); 2668 case ATOMIC_CONSTR: 2669 return satisfy_atom (t, args, info); 2670 default: 2671 gcc_unreachable (); 2672 } 2673} 2674 2675/* Check that the normalized constraint T is satisfied for ARGS. */ 2676 2677static tree 2678satisfy_constraint (tree t, tree args, subst_info info) 2679{ 2680 auto_timevar time (TV_CONSTRAINT_SAT); 2681 2682 /* Turn off template processing. Constraint satisfaction only applies 2683 to non-dependent terms, so we want to ensure full checking here. */ 2684 processing_template_decl_sentinel proc (true); 2685 2686 /* We need to check access during satisfaction. */ 2687 deferring_access_check_sentinel acs (dk_no_deferred); 2688 2689 return satisfy_constraint_r (t, args, info); 2690} 2691 2692/* Check the normalized constraints T against ARGS, returning a satisfaction 2693 value (either true, false, or error). */ 2694 2695static tree 2696satisfy_associated_constraints (tree t, tree args, subst_info info) 2697{ 2698 /* If there are no constraints then this is trivially satisfied. */ 2699 if (!t) 2700 return boolean_true_node; 2701 2702 /* If any arguments depend on template parameters, we can't 2703 check constraints. Pretend they're satisfied for now. */ 2704 if (args && uses_template_parms (args)) 2705 return boolean_true_node; 2706 2707 return satisfy_constraint (t, args, info); 2708} 2709 2710/* Evaluate EXPR as a constraint expression using ARGS, returning a 2711 satisfaction value. */ 2712 2713static tree 2714satisfy_constraint_expression (tree t, tree args, subst_info info) 2715{ 2716 if (t == error_mark_node) 2717 return error_mark_node; 2718 2719 gcc_assert (EXPR_P (t)); 2720 2721 /* Get the normalized constraints. */ 2722 tree norm; 2723 if (args == NULL_TREE && concept_check_p (t)) 2724 { 2725 tree id = unpack_concept_check (t); 2726 args = TREE_OPERAND (id, 1); 2727 tree tmpl = get_concept_check_template (id); 2728 norm = normalize_concept_definition (tmpl, info.noisy ()); 2729 } 2730 else 2731 norm = normalize_constraint_expression (t, info.noisy ()); 2732 2733 /* Perform satisfaction. */ 2734 return satisfy_constraint (norm, args, info); 2735} 2736 2737/* Used only to evaluate requires-expressions during constant expression 2738 evaluation. */ 2739 2740tree 2741satisfy_constraint_expression (tree expr) 2742{ 2743 subst_info info (tf_none, NULL_TREE); 2744 return satisfy_constraint_expression (expr, NULL_TREE, info); 2745} 2746 2747static tree 2748satisfy_declaration_constraints (tree t, subst_info info) 2749{ 2750 gcc_assert (DECL_P (t)); 2751 const tree saved_t = t; 2752 2753 /* For inherited constructors, consider the original declaration; 2754 it has the correct template information attached. */ 2755 t = strip_inheriting_ctors (t); 2756 tree inh_ctor_targs = NULL_TREE; 2757 if (t != saved_t) 2758 if (tree ti = DECL_TEMPLATE_INFO (saved_t)) 2759 /* The inherited constructor points to an instantiation of a constructor 2760 template; remember its template arguments. */ 2761 inh_ctor_targs = TI_ARGS (ti); 2762 2763 /* Update the declaration for diagnostics. */ 2764 info.in_decl = t; 2765 2766 if (info.quiet ()) 2767 if (tree *result = hash_map_safe_get (decl_satisfied_cache, saved_t)) 2768 return *result; 2769 2770 /* Get the normalized constraints. */ 2771 tree norm = NULL_TREE; 2772 tree args = NULL_TREE; 2773 if (tree ti = DECL_TEMPLATE_INFO (t)) 2774 { 2775 tree tmpl = TI_TEMPLATE (ti); 2776 norm = normalize_template_requirements (tmpl, info.noisy ()); 2777 2778 /* The initial parameter mapping is the complete set of 2779 template arguments substituted into the declaration. */ 2780 args = TI_ARGS (ti); 2781 if (inh_ctor_targs) 2782 args = add_outermost_template_args (args, inh_ctor_targs); 2783 } 2784 else 2785 { 2786 /* These should be empty until we allow constraints on non-templates. */ 2787 norm = normalize_nontemplate_requirements (t, info.noisy ()); 2788 } 2789 2790 tree result = boolean_true_node; 2791 if (norm) 2792 { 2793 if (!push_tinst_level (t)) 2794 return result; 2795 push_access_scope (t); 2796 result = satisfy_associated_constraints (norm, args, info); 2797 pop_access_scope (t); 2798 pop_tinst_level (); 2799 } 2800 2801 if (info.quiet ()) 2802 hash_map_safe_put<hm_ggc> (decl_satisfied_cache, saved_t, result); 2803 2804 return result; 2805} 2806 2807static tree 2808satisfy_declaration_constraints (tree t, tree args, subst_info info) 2809{ 2810 /* Update the declaration for diagnostics. */ 2811 info.in_decl = t; 2812 2813 gcc_assert (TREE_CODE (t) == TEMPLATE_DECL); 2814 if (tree norm = normalize_template_requirements (t, info.noisy ())) 2815 { 2816 tree pattern = DECL_TEMPLATE_RESULT (t); 2817 push_access_scope (pattern); 2818 tree result = satisfy_associated_constraints (norm, args, info); 2819 pop_access_scope (pattern); 2820 return result; 2821 } 2822 2823 return boolean_true_node; 2824} 2825 2826static tree 2827constraint_satisfaction_value (tree t, tsubst_flags_t complain) 2828{ 2829 subst_info info (complain, NULL_TREE); 2830 tree r; 2831 if (DECL_P (t)) 2832 r = satisfy_declaration_constraints (t, info); 2833 else 2834 r = satisfy_constraint_expression (t, NULL_TREE, info); 2835 if (r == error_mark_node && info.quiet () 2836 && !(DECL_P (t) && TREE_NO_WARNING (t))) 2837 { 2838 constraint_satisfaction_value (t, tf_warning_or_error); 2839 if (DECL_P (t)) 2840 /* Avoid giving these errors again. */ 2841 TREE_NO_WARNING (t) = true; 2842 } 2843 return r; 2844} 2845 2846static tree 2847constraint_satisfaction_value (tree t, tree args, tsubst_flags_t complain) 2848{ 2849 subst_info info (complain, NULL_TREE); 2850 tree r; 2851 if (DECL_P (t)) 2852 r = satisfy_declaration_constraints (t, args, info); 2853 else 2854 r = satisfy_constraint_expression (t, args, info); 2855 if (r == error_mark_node && info.quiet ()) 2856 constraint_satisfaction_value (t, args, tf_warning_or_error); 2857 return r; 2858} 2859 2860/* True iff the result of satisfying T is BOOLEAN_TRUE_NODE and false 2861 otherwise, even in the case of errors. */ 2862 2863bool 2864constraints_satisfied_p (tree t) 2865{ 2866 if (!flag_concepts) 2867 return true; 2868 2869 return constraint_satisfaction_value (t, tf_none) == boolean_true_node; 2870} 2871 2872/* True iff the result of satisfying T with ARGS is BOOLEAN_TRUE_NODE 2873 and false otherwise, even in the case of errors. */ 2874 2875bool 2876constraints_satisfied_p (tree t, tree args) 2877{ 2878 if (!flag_concepts) 2879 return true; 2880 2881 return constraint_satisfaction_value (t, args, tf_none) == boolean_true_node; 2882} 2883 2884/* Evaluate a concept check of the form C<ARGS>. This is only used for the 2885 evaluation of template-ids as id-expressions. */ 2886 2887tree 2888evaluate_concept_check (tree check, tsubst_flags_t complain) 2889{ 2890 if (check == error_mark_node) 2891 return error_mark_node; 2892 2893 gcc_assert (concept_check_p (check)); 2894 2895 /* Check for satisfaction without diagnostics. */ 2896 subst_info quiet (tf_none, NULL_TREE); 2897 tree result = satisfy_constraint_expression (check, NULL_TREE, quiet); 2898 if (result == error_mark_node && (complain & tf_error)) 2899 { 2900 /* Replay the error with re-normalized requirements. */ 2901 subst_info noisy (tf_warning_or_error, NULL_TREE); 2902 satisfy_constraint_expression (check, NULL_TREE, noisy); 2903 } 2904 return result; 2905} 2906 2907/*--------------------------------------------------------------------------- 2908 Semantic analysis of requires-expressions 2909---------------------------------------------------------------------------*/ 2910 2911/* Finish a requires expression for the given PARMS (possibly 2912 null) and the non-empty sequence of requirements. */ 2913 2914tree 2915finish_requires_expr (location_t loc, tree parms, tree reqs) 2916{ 2917 /* Modify the declared parameters by removing their context 2918 so they don't refer to the enclosing scope and explicitly 2919 indicating that they are constraint variables. */ 2920 for (tree parm = parms; parm; parm = DECL_CHAIN (parm)) 2921 { 2922 DECL_CONTEXT (parm) = NULL_TREE; 2923 CONSTRAINT_VAR_P (parm) = true; 2924 } 2925 2926 /* Build the node. */ 2927 tree r = build_min (REQUIRES_EXPR, boolean_type_node, parms, reqs); 2928 TREE_SIDE_EFFECTS (r) = false; 2929 TREE_CONSTANT (r) = true; 2930 SET_EXPR_LOCATION (r, loc); 2931 return r; 2932} 2933 2934/* Construct a requirement for the validity of EXPR. */ 2935 2936tree 2937finish_simple_requirement (location_t loc, tree expr) 2938{ 2939 tree r = build_nt (SIMPLE_REQ, expr); 2940 SET_EXPR_LOCATION (r, loc); 2941 return r; 2942} 2943 2944/* Construct a requirement for the validity of TYPE. */ 2945 2946tree 2947finish_type_requirement (location_t loc, tree type) 2948{ 2949 tree r = build_nt (TYPE_REQ, type); 2950 SET_EXPR_LOCATION (r, loc); 2951 return r; 2952} 2953 2954/* Construct a requirement for the validity of EXPR, along with 2955 its properties. if TYPE is non-null, then it specifies either 2956 an implicit conversion or argument deduction constraint, 2957 depending on whether any placeholders occur in the type name. 2958 NOEXCEPT_P is true iff the noexcept keyword was specified. */ 2959 2960tree 2961finish_compound_requirement (location_t loc, tree expr, tree type, bool noexcept_p) 2962{ 2963 tree req = build_nt (COMPOUND_REQ, expr, type); 2964 SET_EXPR_LOCATION (req, loc); 2965 COMPOUND_REQ_NOEXCEPT_P (req) = noexcept_p; 2966 return req; 2967} 2968 2969/* Finish a nested requirement. */ 2970 2971tree 2972finish_nested_requirement (location_t loc, tree expr) 2973{ 2974 /* Currently open template headers have dummy arg vectors, so don't 2975 pass into normalization. */ 2976 tree norm = normalize_constraint_expression (expr, NULL_TREE, false); 2977 tree args = current_template_parms 2978 ? template_parms_to_args (current_template_parms) : NULL_TREE; 2979 2980 /* Save the normalized constraint and complete set of normalization 2981 arguments with the requirement. We keep the complete set of arguments 2982 around for re-normalization during diagnostics. */ 2983 tree info = build_tree_list (args, norm); 2984 2985 /* Build the constraint, saving its normalization as its type. */ 2986 tree r = build1 (NESTED_REQ, info, expr); 2987 SET_EXPR_LOCATION (r, loc); 2988 return r; 2989} 2990 2991/* Check that FN satisfies the structural requirements of a 2992 function concept definition. */ 2993tree 2994check_function_concept (tree fn) 2995{ 2996 /* Check that the function is comprised of only a return statement. */ 2997 tree body = DECL_SAVED_TREE (fn); 2998 if (TREE_CODE (body) == BIND_EXPR) 2999 body = BIND_EXPR_BODY (body); 3000 3001 /* Sometimes a function call results in the creation of clean up 3002 points. Allow these to be preserved in the body of the 3003 constraint, as we might actually need them for some constexpr 3004 evaluations. */ 3005 if (TREE_CODE (body) == CLEANUP_POINT_EXPR) 3006 body = TREE_OPERAND (body, 0); 3007 3008 /* Check that the definition is written correctly. */ 3009 if (TREE_CODE (body) != RETURN_EXPR) 3010 { 3011 location_t loc = DECL_SOURCE_LOCATION (fn); 3012 if (TREE_CODE (body) == STATEMENT_LIST && !STATEMENT_LIST_HEAD (body)) 3013 { 3014 if (seen_error ()) 3015 /* The definition was probably erroneous, not empty. */; 3016 else 3017 error_at (loc, "definition of concept %qD is empty", fn); 3018 } 3019 else 3020 error_at (loc, "definition of concept %qD has multiple statements", fn); 3021 } 3022 3023 return NULL_TREE; 3024} 3025 3026 3027// Check that a constrained friend declaration function declaration, 3028// FN, is admissible. This is the case only when the declaration depends 3029// on template parameters and does not declare a specialization. 3030void 3031check_constrained_friend (tree fn, tree reqs) 3032{ 3033 if (fn == error_mark_node) 3034 return; 3035 gcc_assert (TREE_CODE (fn) == FUNCTION_DECL); 3036 3037 // If there are not constraints, this cannot be an error. 3038 if (!reqs) 3039 return; 3040 3041 // Constrained friend functions that don't depend on template 3042 // arguments are effectively meaningless. 3043 if (!uses_template_parms (TREE_TYPE (fn))) 3044 { 3045 error_at (location_of (fn), 3046 "constrained friend does not depend on template parameters"); 3047 return; 3048 } 3049} 3050 3051/*--------------------------------------------------------------------------- 3052 Equivalence of constraints 3053---------------------------------------------------------------------------*/ 3054 3055/* Returns true when A and B are equivalent constraints. */ 3056bool 3057equivalent_constraints (tree a, tree b) 3058{ 3059 gcc_assert (!a || TREE_CODE (a) == CONSTRAINT_INFO); 3060 gcc_assert (!b || TREE_CODE (b) == CONSTRAINT_INFO); 3061 return cp_tree_equal (a, b); 3062} 3063 3064/* Returns true if the template declarations A and B have equivalent 3065 constraints. This is the case when A's constraints subsume B's and 3066 when B's also constrain A's. */ 3067bool 3068equivalently_constrained (tree d1, tree d2) 3069{ 3070 gcc_assert (TREE_CODE (d1) == TREE_CODE (d2)); 3071 return equivalent_constraints (get_constraints (d1), get_constraints (d2)); 3072} 3073 3074/*--------------------------------------------------------------------------- 3075 Partial ordering of constraints 3076---------------------------------------------------------------------------*/ 3077 3078/* Returns true when the constraints in A subsume those in B. */ 3079 3080bool 3081subsumes_constraints (tree a, tree b) 3082{ 3083 gcc_assert (!a || TREE_CODE (a) == CONSTRAINT_INFO); 3084 gcc_assert (!b || TREE_CODE (b) == CONSTRAINT_INFO); 3085 return subsumes (a, b); 3086} 3087 3088/* Returns true when the constraints in CI (with arguments 3089 ARGS) strictly subsume the associated constraints of TMPL. */ 3090 3091bool 3092strictly_subsumes (tree ci, tree args, tree tmpl) 3093{ 3094 tree n1 = get_normalized_constraints_from_info (ci, args, NULL_TREE); 3095 tree n2 = get_normalized_constraints_from_decl (tmpl); 3096 3097 return subsumes (n1, n2) && !subsumes (n2, n1); 3098} 3099 3100/* REturns true when the constraints in CI (with arguments ARGS) subsume 3101 the associated constraints of TMPL. */ 3102 3103bool 3104weakly_subsumes (tree ci, tree args, tree tmpl) 3105{ 3106 tree n1 = get_normalized_constraints_from_info (ci, args, NULL_TREE); 3107 tree n2 = get_normalized_constraints_from_decl (tmpl); 3108 3109 return subsumes (n1, n2); 3110} 3111 3112/* Determines which of the declarations, A or B, is more constrained. 3113 That is, which declaration's constraints subsume but are not subsumed 3114 by the other's? 3115 3116 Returns 1 if D1 is more constrained than D2, -1 if D2 is more constrained 3117 than D1, and 0 otherwise. */ 3118 3119int 3120more_constrained (tree d1, tree d2) 3121{ 3122 tree n1 = get_normalized_constraints_from_decl (d1); 3123 tree n2 = get_normalized_constraints_from_decl (d2); 3124 3125 int winner = 0; 3126 if (subsumes (n1, n2)) 3127 ++winner; 3128 if (subsumes (n2, n1)) 3129 --winner; 3130 return winner; 3131} 3132 3133/* Return whether D1 is at least as constrained as D2. */ 3134 3135bool 3136at_least_as_constrained (tree d1, tree d2) 3137{ 3138 tree n1 = get_normalized_constraints_from_decl (d1); 3139 tree n2 = get_normalized_constraints_from_decl (d2); 3140 3141 return subsumes (n1, n2); 3142} 3143 3144/*--------------------------------------------------------------------------- 3145 Constraint diagnostics 3146---------------------------------------------------------------------------*/ 3147 3148/* Returns the best location to diagnose a constraint error. */ 3149 3150static location_t 3151get_constraint_error_location (tree t) 3152{ 3153 if (location_t loc = cp_expr_location (t)) 3154 return loc; 3155 3156 /* If we have a specific location give it. */ 3157 tree expr = CONSTR_EXPR (t); 3158 if (location_t loc = cp_expr_location (expr)) 3159 return loc; 3160 3161 /* If the constraint is normalized from a requires-clause, give 3162 the location as that of the constrained declaration. */ 3163 tree cxt = CONSTR_CONTEXT (t); 3164 tree src = cxt ? TREE_VALUE (cxt) : NULL_TREE; 3165 if (!src) 3166 /* TODO: This only happens for constrained non-template declarations. */ 3167 ; 3168 else if (DECL_P (src)) 3169 return DECL_SOURCE_LOCATION (src); 3170 /* Otherwise, give the location as the defining concept. */ 3171 else if (concept_check_p (src)) 3172 { 3173 tree id = unpack_concept_check (src); 3174 tree tmpl = TREE_OPERAND (id, 0); 3175 if (OVL_P (tmpl)) 3176 tmpl = OVL_FIRST (tmpl); 3177 return DECL_SOURCE_LOCATION (tmpl); 3178 } 3179 3180 return input_location; 3181} 3182 3183/* Emit a diagnostic for a failed trait. */ 3184 3185void 3186diagnose_trait_expr (tree expr, tree map) 3187{ 3188 location_t loc = cp_expr_location (expr); 3189 tree args = get_mapped_args (map); 3190 3191 /* Build a "fake" version of the instantiated trait, so we can 3192 get the instantiated types from result. */ 3193 ++processing_template_decl; 3194 expr = tsubst_expr (expr, args, tf_none, NULL_TREE, false); 3195 --processing_template_decl; 3196 3197 tree t1 = TRAIT_EXPR_TYPE1 (expr); 3198 tree t2 = TRAIT_EXPR_TYPE2 (expr); 3199 switch (TRAIT_EXPR_KIND (expr)) 3200 { 3201 case CPTK_HAS_NOTHROW_ASSIGN: 3202 inform (loc, " %qT is not %<nothrow%> copy assignable", t1); 3203 break; 3204 case CPTK_HAS_NOTHROW_CONSTRUCTOR: 3205 inform (loc, " %qT is not %<nothrow%> default constructible", t1); 3206 break; 3207 case CPTK_HAS_NOTHROW_COPY: 3208 inform (loc, " %qT is not %<nothrow%> copy constructible", t1); 3209 break; 3210 case CPTK_HAS_TRIVIAL_ASSIGN: 3211 inform (loc, " %qT is not trivially copy assignable", t1); 3212 break; 3213 case CPTK_HAS_TRIVIAL_CONSTRUCTOR: 3214 inform (loc, " %qT is not trivially default constructible", t1); 3215 break; 3216 case CPTK_HAS_TRIVIAL_COPY: 3217 inform (loc, " %qT is not trivially copy constructible", t1); 3218 break; 3219 case CPTK_HAS_TRIVIAL_DESTRUCTOR: 3220 inform (loc, " %qT is not trivially destructible", t1); 3221 break; 3222 case CPTK_HAS_VIRTUAL_DESTRUCTOR: 3223 inform (loc, " %qT does not have a virtual destructor", t1); 3224 break; 3225 case CPTK_IS_ABSTRACT: 3226 inform (loc, " %qT is not an abstract class", t1); 3227 break; 3228 case CPTK_IS_BASE_OF: 3229 inform (loc, " %qT is not a base of %qT", t1, t2); 3230 break; 3231 case CPTK_IS_CLASS: 3232 inform (loc, " %qT is not a class", t1); 3233 break; 3234 case CPTK_IS_EMPTY: 3235 inform (loc, " %qT is not an empty class", t1); 3236 break; 3237 case CPTK_IS_ENUM: 3238 inform (loc, " %qT is not an enum", t1); 3239 break; 3240 case CPTK_IS_FINAL: 3241 inform (loc, " %qT is not a final class", t1); 3242 break; 3243 case CPTK_IS_LITERAL_TYPE: 3244 inform (loc, " %qT is not a literal type", t1); 3245 break; 3246 case CPTK_IS_POD: 3247 inform (loc, " %qT is not a POD type", t1); 3248 break; 3249 case CPTK_IS_POLYMORPHIC: 3250 inform (loc, " %qT is not a polymorphic type", t1); 3251 break; 3252 case CPTK_IS_SAME_AS: 3253 inform (loc, " %qT is not the same as %qT", t1, t2); 3254 break; 3255 case CPTK_IS_STD_LAYOUT: 3256 inform (loc, " %qT is not an standard layout type", t1); 3257 break; 3258 case CPTK_IS_TRIVIAL: 3259 inform (loc, " %qT is not a trivial type", t1); 3260 break; 3261 case CPTK_IS_UNION: 3262 inform (loc, " %qT is not a union", t1); 3263 break; 3264 default: 3265 gcc_unreachable (); 3266 } 3267} 3268 3269static tree 3270diagnose_valid_expression (tree expr, tree args, tree in_decl) 3271{ 3272 tree result = tsubst_expr (expr, args, tf_none, in_decl, false); 3273 if (result != error_mark_node 3274 && convert_to_void (result, ICV_STATEMENT, tf_none) != error_mark_node) 3275 return result; 3276 3277 location_t loc = cp_expr_loc_or_input_loc (expr); 3278 if (diagnosing_failed_constraint::replay_errors_p ()) 3279 { 3280 /* Replay the substitution error. */ 3281 inform (loc, "the required expression %qE is invalid, because", expr); 3282 if (result == error_mark_node) 3283 tsubst_expr (expr, args, tf_error, in_decl, false); 3284 else 3285 convert_to_void (result, ICV_STATEMENT, tf_error); 3286 } 3287 else 3288 inform (loc, "the required expression %qE is invalid", expr); 3289 3290 return error_mark_node; 3291} 3292 3293static tree 3294diagnose_valid_type (tree type, tree args, tree in_decl) 3295{ 3296 tree result = tsubst (type, args, tf_none, in_decl); 3297 if (result != error_mark_node) 3298 return result; 3299 3300 location_t loc = cp_expr_loc_or_input_loc (type); 3301 if (diagnosing_failed_constraint::replay_errors_p ()) 3302 { 3303 /* Replay the substitution error. */ 3304 inform (loc, "the required type %qT is invalid, because", type); 3305 tsubst (type, args, tf_error, in_decl); 3306 } 3307 else 3308 inform (loc, "the required type %qT is invalid", type); 3309 3310 return error_mark_node; 3311} 3312 3313static void 3314diagnose_simple_requirement (tree req, tree args, tree in_decl) 3315{ 3316 diagnose_valid_expression (TREE_OPERAND (req, 0), args, in_decl); 3317} 3318 3319static void 3320diagnose_compound_requirement (tree req, tree args, tree in_decl) 3321{ 3322 tree expr = TREE_OPERAND (req, 0); 3323 expr = diagnose_valid_expression (expr, args, in_decl); 3324 if (expr == error_mark_node) 3325 return; 3326 3327 location_t loc = cp_expr_loc_or_input_loc (expr); 3328 3329 /* Check the noexcept condition. */ 3330 if (COMPOUND_REQ_NOEXCEPT_P (req) && !expr_noexcept_p (expr, tf_none)) 3331 inform (loc, "%qE is not %<noexcept%>", expr); 3332 3333 tree type = TREE_OPERAND (req, 1); 3334 type = diagnose_valid_type (type, args, in_decl); 3335 if (type == error_mark_node) 3336 return; 3337 3338 if (type) 3339 { 3340 subst_info quiet (tf_none, in_decl); 3341 subst_info noisy (tf_error, in_decl); 3342 3343 /* Check the expression against the result type. */ 3344 if (tree placeholder = type_uses_auto (type)) 3345 { 3346 if (!type_deducible_p (expr, type, placeholder, args, quiet)) 3347 { 3348 tree orig_expr = TREE_OPERAND (req, 0); 3349 if (diagnosing_failed_constraint::replay_errors_p ()) 3350 { 3351 inform (loc, 3352 "%qE does not satisfy return-type-requirement, " 3353 "because", orig_expr); 3354 /* Further explain the reason for the error. */ 3355 type_deducible_p (expr, type, placeholder, args, noisy); 3356 } 3357 else 3358 inform (loc, "%qE does not satisfy return-type-requirement", 3359 orig_expr); 3360 } 3361 } 3362 else if (!expression_convertible_p (expr, type, quiet)) 3363 { 3364 tree orig_expr = TREE_OPERAND (req, 0); 3365 if (diagnosing_failed_constraint::replay_errors_p ()) 3366 { 3367 inform (loc, "cannot convert %qE to %qT because", orig_expr, type); 3368 /* Further explain the reason for the error. */ 3369 expression_convertible_p (expr, type, noisy); 3370 } 3371 else 3372 inform (loc, "cannot convert %qE to %qT", orig_expr, type); 3373 } 3374 } 3375} 3376 3377static void 3378diagnose_type_requirement (tree req, tree args, tree in_decl) 3379{ 3380 tree type = TREE_OPERAND (req, 0); 3381 diagnose_valid_type (type, args, in_decl); 3382} 3383 3384static void 3385diagnose_nested_requirement (tree req, tree args) 3386{ 3387 /* Quietly check for satisfaction first. We can elaborate details 3388 later if needed. */ 3389 tree norm = TREE_VALUE (TREE_TYPE (req)); 3390 subst_info info (tf_none, NULL_TREE); 3391 tree result = satisfy_constraint (norm, args, info); 3392 if (result == boolean_true_node) 3393 return; 3394 3395 tree expr = TREE_OPERAND (req, 0); 3396 location_t loc = cp_expr_location (expr); 3397 if (diagnosing_failed_constraint::replay_errors_p ()) 3398 { 3399 /* Replay the substitution error. */ 3400 inform (loc, "nested requirement %qE is not satisfied, because", expr); 3401 subst_info noisy (tf_warning_or_error, NULL_TREE); 3402 satisfy_constraint_expression (expr, args, noisy); 3403 } 3404 else 3405 inform (loc, "nested requirement %qE is not satisfied", expr); 3406 3407} 3408 3409static void 3410diagnose_requirement (tree req, tree args, tree in_decl) 3411{ 3412 iloc_sentinel loc_s (cp_expr_location (req)); 3413 switch (TREE_CODE (req)) 3414 { 3415 case SIMPLE_REQ: 3416 return diagnose_simple_requirement (req, args, in_decl); 3417 case COMPOUND_REQ: 3418 return diagnose_compound_requirement (req, args, in_decl); 3419 case TYPE_REQ: 3420 return diagnose_type_requirement (req, args, in_decl); 3421 case NESTED_REQ: 3422 return diagnose_nested_requirement (req, args); 3423 default: 3424 gcc_unreachable (); 3425 } 3426} 3427 3428static void 3429diagnose_requires_expr (tree expr, tree map, tree in_decl) 3430{ 3431 local_specialization_stack stack (lss_copy); 3432 tree parms = TREE_OPERAND (expr, 0); 3433 tree body = TREE_OPERAND (expr, 1); 3434 tree args = get_mapped_args (map); 3435 3436 cp_unevaluated u; 3437 subst_info info (tf_warning_or_error, NULL_TREE); 3438 tree vars = tsubst_constraint_variables (parms, args, info); 3439 if (vars == error_mark_node) 3440 return; 3441 3442 tree p = body; 3443 while (p) 3444 { 3445 tree req = TREE_VALUE (p); 3446 diagnose_requirement (req, args, in_decl); 3447 p = TREE_CHAIN (p); 3448 } 3449} 3450 3451/* Diagnose a substitution failure in the atomic constraint T when applied 3452 with the instantiated parameter mapping MAP. */ 3453 3454static void 3455diagnose_atomic_constraint (tree t, tree map, tree result, subst_info info) 3456{ 3457 /* If the constraint is already ill-formed, we've previously diagnosed 3458 the reason. We should still say why the constraints aren't satisfied. */ 3459 if (t == error_mark_node) 3460 { 3461 location_t loc; 3462 if (info.in_decl) 3463 loc = DECL_SOURCE_LOCATION (info.in_decl); 3464 else 3465 loc = input_location; 3466 inform (loc, "invalid constraints"); 3467 return; 3468 } 3469 3470 location_t loc = get_constraint_error_location (t); 3471 iloc_sentinel loc_s (loc); 3472 3473 /* Generate better diagnostics for certain kinds of expressions. */ 3474 tree expr = ATOMIC_CONSTR_EXPR (t); 3475 STRIP_ANY_LOCATION_WRAPPER (expr); 3476 switch (TREE_CODE (expr)) 3477 { 3478 case TRAIT_EXPR: 3479 diagnose_trait_expr (expr, map); 3480 break; 3481 case REQUIRES_EXPR: 3482 diagnose_requires_expr (expr, map, info.in_decl); 3483 break; 3484 default: 3485 tree a = copy_node (t); 3486 ATOMIC_CONSTR_MAP (a) = map; 3487 if (!same_type_p (TREE_TYPE (result), boolean_type_node)) 3488 error_at (loc, "constraint %qE has type %qT, not %<bool%>", 3489 a, TREE_TYPE (result)); 3490 else 3491 inform (loc, "the expression %qE evaluated to %<false%>", a); 3492 ggc_free (a); 3493 } 3494} 3495 3496GTY(()) tree current_failed_constraint; 3497 3498diagnosing_failed_constraint:: 3499diagnosing_failed_constraint (tree t, tree args, bool diag) 3500 : diagnosing_error (diag) 3501{ 3502 if (diagnosing_error) 3503 { 3504 current_failed_constraint 3505 = tree_cons (args, t, current_failed_constraint); 3506 ++current_constraint_diagnosis_depth; 3507 } 3508} 3509 3510diagnosing_failed_constraint:: 3511~diagnosing_failed_constraint () 3512{ 3513 if (diagnosing_error) 3514 { 3515 --current_constraint_diagnosis_depth; 3516 if (current_failed_constraint) 3517 current_failed_constraint = TREE_CHAIN (current_failed_constraint); 3518 } 3519 3520} 3521 3522/* Whether we are allowed to replay an error that underlies a constraint failure 3523 at the current diagnosis depth. */ 3524 3525bool 3526diagnosing_failed_constraint::replay_errors_p () 3527{ 3528 if (current_constraint_diagnosis_depth >= concepts_diagnostics_max_depth) 3529 { 3530 concepts_diagnostics_max_depth_exceeded_p = true; 3531 return false; 3532 } 3533 else 3534 return true; 3535} 3536 3537/* Emit diagnostics detailing the failure ARGS to satisfy the constraints 3538 of T. Here, T can be either a constraint or a declaration. */ 3539 3540void 3541diagnose_constraints (location_t loc, tree t, tree args) 3542{ 3543 inform (loc, "constraints not satisfied"); 3544 3545 if (concepts_diagnostics_max_depth == 0) 3546 return; 3547 3548 /* Replay satisfaction, but diagnose errors. */ 3549 if (!args) 3550 constraint_satisfaction_value (t, tf_warning_or_error); 3551 else 3552 constraint_satisfaction_value (t, args, tf_warning_or_error); 3553 3554 static bool suggested_p; 3555 if (concepts_diagnostics_max_depth_exceeded_p 3556 && current_constraint_diagnosis_depth == 0 3557 && !suggested_p) 3558 { 3559 inform (UNKNOWN_LOCATION, 3560 "set %qs to at least %d for more detail", 3561 "-fconcepts-diagnostics-depth=", 3562 concepts_diagnostics_max_depth + 1); 3563 suggested_p = true; 3564 } 3565} 3566 3567#include "gt-cp-constraint.h" 3568