| blob | dca8e5090e2677fb46ca7672e96a7d94f505bf30 |
1 /* Functions related to invoking -*- C++ -*- methods and overloaded functions.
2 Copyright (C) 1987-2024 Free Software Foundation, Inc.
3 Contributed by Michael Tiemann (tiemann@cygnus.com) and
4 modified by Brendan Kehoe (brendan@cygnus.com).
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3, or (at your option)
11 any later version.
13 GCC is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3. If not see
20 <http://www.gnu.org/licenses/>. */
23 /* High-level class interface. */
48 /* The various kinds of conversion. */
51 ck_identity,
52 ck_lvalue,
53 ck_fnptr,
54 ck_qual,
55 ck_std,
56 ck_ptr,
57 ck_pmem,
58 ck_base,
59 ck_ref_bind,
60 ck_user,
61 ck_ambig,
62 ck_list,
63 ck_aggr,
64 ck_rvalue,
65 /* When LOOKUP_SHORTCUT_BAD_CONVS is set, we may return a conversion of
66 this kind whenever we know the true conversion is either bad or outright
67 invalid, but we don't want to attempt to compute the bad conversion (for
68 sake of avoiding unnecessary instantiation). bad_p should always be set
69 for these. */
70 ck_deferred_bad,
71 };
73 /* The rank of the conversion. Order of the enumerals matters; better
74 conversions should come earlier in the list. */
77 cr_identity,
78 cr_exact,
79 cr_promotion,
80 cr_std,
81 cr_pbool,
82 cr_user,
83 cr_ellipsis,
84 cr_bad
85 };
87 /* An implicit conversion sequence, in the sense of [over.best.ics].
88 The first conversion to be performed is at the end of the chain.
89 That conversion is always a cr_identity conversion. */
92 /* The kind of conversion represented by this step. */
93 conversion_kind kind;
94 /* The rank of this conversion. */
95 conversion_rank rank;
99 /* True if this conversion would be permitted with a bending of
100 language standards, e.g. disregarding pointer qualifiers or
101 converting integers to pointers. */
103 /* If KIND is ck_ref_bind or ck_base, true to indicate that a
104 temporary should be created to hold the result of the
105 conversion. If KIND is ck_ambig or ck_user, true means force
106 copy-initialization. */
108 /* If KIND is ck_ptr or ck_pmem, true to indicate that a conversion
109 from a pointer-to-derived to pointer-to-base is being performed. */
111 /* If KIND is ck_ref_bind, true when either an lvalue reference is
112 being bound to an lvalue expression or an rvalue reference is
113 being bound to an rvalue expression. If KIND is ck_rvalue or ck_base,
114 true when we are treating an lvalue as an rvalue (12.8p33). If
115 ck_identity, we will be binding a reference directly or decaying to
116 a pointer. */
119 /* Whether check_narrowing should only check TREE_CONSTANTs; used
120 in build_converted_constant_expr. */
122 /* True if this conversion is taking place in a copy-initialization context
123 and we should only consider converting constructors. Only set in
124 ck_base and ck_rvalue. */
126 /* The type of the expression resulting from the conversion. */
127 tree type;
129 /* The next conversion in the chain. Since the conversions are
130 arranged from outermost to innermost, the NEXT conversion will
131 actually be performed before this conversion. This variant is
132 used only when KIND is neither ck_identity, ck_aggr, ck_ambig nor
133 ck_list. Please use the next_conversion function instead
134 of using this field directly. */
136 /* The expression at the beginning of the conversion chain. This
137 variant is used only if KIND is ck_identity, ck_aggr, or ck_ambig.
138 You can use conv_get_original_expr to get this expression. */
139 tree expr;
140 /* The array of conversions for an initializer_list, so this
141 variant is used only when KIN D is ck_list. */
144 /* The function candidate corresponding to this conversion
145 sequence. This field is only used if KIND is ck_user. */
147 };
149 #define CONVERSION_RANK(NODE) \
150 ((NODE)->bad_p ? cr_bad \
151 : (NODE)->ellipsis_p ? cr_ellipsis \
152 : (NODE)->user_conv_p ? cr_user \
153 : (NODE)->rank)
155 #define BAD_CONVERSION_RANK(NODE) \
156 ((NODE)->ellipsis_p ? cr_ellipsis \
157 : (NODE)->user_conv_p ? cr_user \
158 : (NODE)->rank)
167 tsubst_flags_t);
174 tsubst_flags_t);
178 tsubst_flags_t);
199 tsubst_flags_t);
201 tsubst_flags_t);
220 tsubst_flags_t);
228 /* Returns nonzero iff the destructor name specified in NAME matches BASETYPE.
229 NAME can take many forms... */
231 bool
233 {
234 /* Just accept something we've already complained about. */
243 {
249 /* Otherwise lookup the name, it could be an unrelated typedef
250 of the correct type. */
257 }
258 else
259 {
260 /* In the case of:
262 template <class T> struct S { ~S(); };
263 int i;
264 i.~S();
266 NAME will be a class template. */
269 }
272 }
274 /* We want the address of a function or method. We avoid creating a
275 pointer-to-member function. */
277 tree
279 {
282 /* We have to do these by hand to avoid real pointer to member
283 functions. */
285 {
287 {
291 complain);
292 }
294 }
298 else
302 }
304 /* Build a CALL_EXPR, we can handle FUNCTION_TYPEs, METHOD_TYPEs, or
305 POINTER_TYPE to those. Note, pointer to member function types
306 (TYPE_PTRMEMFUNC_P) must be handled by our callers. There are
307 two variants. build_call_a is the primitive taking an array of
308 arguments, while build_call_n is a wrapper that handles varargs. */
310 tree
312 {
315 else
316 {
326 }
327 }
329 /* Update various flags in cfun and the call itself based on what is being
330 called. Split out of build_call_a so that bot_manip can use it too. */
332 void
334 {
335 /* Handle both CALL_EXPRs and AGGR_INIT_EXPRs. */
338 /* We check both the decl and the type; a function may be known not to
339 throw without being declared throw(). */
349 {
355 }
358 }
360 tree
362 {
363 tree decl;
364 tree result_type;
365 tree fntype;
374 /* An rvalue has no cv-qualifiers. */
385 {
386 /* We invoke build_call directly for several library
387 functions. These may have been declared normally if
388 we're building libgcc, so we can't just check
389 DECL_ARTIFICIAL. */
394 }
400 /* Don't pass empty class objects by value. This is useful
401 for tags in STL, which are used to control overload resolution.
402 We don't need to handle other cases of copying empty classes. */
405 {
409 {
411 /* We're disconnecting the initializer from its target,
412 don't create a temporary. */
417 }
418 }
421 }
423 /* New overloading code. */
430 };
432 /* Information for providing diagnostics about why overloading failed. */
435 rr_none,
436 rr_arity,
437 rr_explicit_conversion,
438 rr_template_conversion,
439 rr_arg_conversion,
440 rr_bad_arg_conversion,
441 rr_template_unification,
442 rr_invalid_copy,
443 rr_inherited_ctor,
444 rr_constraint_failure,
445 rr_ignored,
446 };
449 /* The index of the argument, 0-based. */
451 /* The actual argument or its type. */
452 tree from;
453 /* The type of the parameter. */
454 tree to_type;
455 /* The location of the argument. */
456 location_t loc;
457 };
462 /* Information about an arity mismatch. */
464 /* The expected number of arguments. */
466 /* The actual number of arguments in the call. */
468 /* Whether EXPECTED should be treated as a lower bound. */
471 /* Information about an argument conversion mismatch. */
473 /* Same, but for bad argument conversions. */
475 /* Information about template unification failures. These are the
476 parameters passed to fn_type_unification. */
478 tree tmpl;
479 tree explicit_targs;
483 tree return_type;
484 unification_kind_t strict;
487 /* Information about template instantiation failures. These are the
488 parameters passed to instantiate_template. */
490 tree tmpl;
491 tree targs;
494 };
497 /* The FUNCTION_DECL that will be called if this candidate is
498 selected by overload resolution. */
499 tree fn;
500 /* If not NULL_TREE, the first argument to use when calling this
501 function. */
502 tree first_arg;
503 /* The rest of the arguments to use when calling this function. If
504 there are no further arguments this may be NULL or it may be an
505 empty vector. */
507 /* The implicit conversion sequences for each of the arguments to
508 FN. */
510 /* The number of implicit conversion sequences. */
512 /* If FN is a user-defined conversion, the standard conversion
513 sequence from the type returned by FN to the desired destination
514 type. */
517 /* If FN is a member function, the binfo indicating the path used to
518 qualify the name of FN at the call site. This path is used to
519 determine whether or not FN is accessible if it is selected by
520 overload resolution. The DECL_CONTEXT of FN will always be a
521 (possibly improper) base of this binfo. */
522 tree access_path;
523 /* If FN is a non-static member function, the binfo indicating the
524 subobject to which the `this' pointer should be converted if FN
525 is selected by overload resolution. The type pointed to by
526 the `this' pointer must correspond to the most derived class
527 indicated by the CONVERSION_PATH. */
528 tree conversion_path;
529 tree template_decl;
530 tree explicit_targs;
535 /* The flags active in add_candidate. */
540 };
542 /* Returns true iff T is a null pointer constant in the sense of
543 [conv.ptr]. */
545 bool
547 {
550 /* [conv.ptr]
552 A null pointer constant is an integer literal ([lex.icon]) with value
553 zero or a prvalue of type std::nullptr_t. */
558 {
561 /* Core issue 903 says only literal 0 is a null pointer constant. */
568 }
570 {
575 }
578 }
580 /* Returns true iff T is a null member pointer value (4.11). */
582 bool
584 {
594 else
596 }
598 /* Returns nonzero if PARMLIST consists of only default parms,
599 ellipsis, and/or undeduced parameter packs. */
601 bool
603 {
610 }
612 /* Allocate N bytes of memory from the conversion obstack. The memory
613 is zeroed before being returned. */
617 {
620 {
623 }
627 }
629 /* RAII class to discard anything added to conversion_obstack. */
631 struct conversion_obstack_sentinel
632 {
636 };
638 /* Allocate rejection reasons. */
642 {
647 }
651 {
658 }
662 location_t loc)
663 {
671 }
675 location_t loc)
676 {
684 }
688 {
695 }
699 {
706 }
713 {
720 /* Copy args to our own storage. */
728 }
732 {
734 }
738 {
741 }
745 {
748 }
750 /* Build a constraint failure record. */
754 {
757 }
759 /* Dynamically allocate a conversion. */
763 {
768 }
770 /* Make sure that all memory on the conversion obstack has been
771 freed. */
773 void
775 {
779 }
781 /* Dynamically allocate an array of N conversions. */
785 {
787 }
789 /* True iff the active member of conversion::u for code CODE is NEXT. */
793 {
799 }
803 {
807 /* Only call this function for conversions that use u.next. */
810 /* Note that the caller is responsible for filling in t->cand for
811 user-defined conversions. */
817 {
834 }
840 }
842 /* Represent a conversion from CTOR, a braced-init-list, to TYPE, a
843 specialization of std::initializer_list<T>, if such a conversion is
844 possible. */
848 {
854 tree val;
856 /* Within a list-initialization we can have more user-defined
857 conversions. */
859 /* But no narrowing conversions. */
862 /* Can't make an array of these types. */
869 {
870 conversion *sub
877 }
885 {
893 }
896 }
898 /* Return the next conversion of the conversion chain (if applicable),
899 or NULL otherwise. Please use this function instead of directly
900 accessing fields of struct conversion. */
904 {
909 }
911 /* Strip to the first ck_user, ck_ambig, ck_list, ck_aggr or ck_identity
912 encountered. */
916 {
922 }
924 /* Subroutine of build_aggr_conv: check whether FROM is a valid aggregate
925 initializer for array type ATYPE. */
927 static bool
929 {
934 {
936 {
941 else
943 complain);
946 }
948 }
954 /* No other valid way to aggregate initialize an array. */
956 }
958 /* Helper for build_aggr_conv. Return true if FIELD is in PSET, or if
959 FIELD has ANON_AGGR_TYPE_P and any initializable field in there recursively
960 is in PSET. */
962 static bool
964 {
970 {
976 }
978 }
980 /* Represent a conversion from CTOR, a braced-init-list, to TYPE, an
981 aggregate class, if such a conversion is possible. */
985 {
992 /* We already called reshape_init in implicit_conversion, but it might not
993 have done anything in the case of parenthesized aggr init. */
995 /* The conversions within the init-list aren't affected by the enclosing
996 context; they're always simple copy-initialization. */
999 /* For designated initializers, verify that each initializer is convertible
1000 to corresponding TREE_TYPE (ce->index) and mark those FIELD_DECLs as
1001 visited. In the following loop then ignore already visited
1002 FIELD_DECLs. */
1005 {
1016 else
1018 complain);
1023 /* For unions, there should be just one initializer. */
1025 {
1029 }
1031 }
1034 {
1041 {
1046 }
1050 /* Value-initialization of reference is ill-formed. */
1052 else
1053 {
1057 }
1061 else
1063 complain);
1070 }
1082 }
1084 /* Represent a conversion from CTOR, a braced-init-list, to TYPE, an
1085 array type, if such a conversion is possible. */
1089 {
1097 /* We might need to propagate the size from the element to the array. */
1102 {
1106 }
1111 {
1112 conversion *sub
1124 }
1133 }
1135 /* Represent a conversion from CTOR, a braced-init-list, to TYPE, a
1136 complex type, if such a conversion is possible. */
1140 tsubst_flags_t complain)
1141 {
1155 {
1156 conversion *sub
1168 }
1177 }
1179 /* Build a representation of the identity conversion from EXPR to
1180 itself. The TYPE should match the type of EXPR, if EXPR is non-NULL. */
1184 {
1192 }
1194 /* Converting from EXPR to TYPE was ambiguous in the sense that there
1195 were multiple user-defined conversions to accomplish the job.
1196 Build a conversion that indicates that ambiguity. */
1200 {
1208 }
1210 tree
1212 {
1216 }
1218 /* Returns the standard conversion path (see [conv]) from type FROM to type
1219 TO, if any. For proper handling of null pointer constants, you must
1220 also pass the expression EXPR to convert from. If C_CAST_P is true,
1221 this conversion is coming from a C-style cast. */
1226 {
1230 tree qualified_to;
1234 {
1237 }
1243 {
1245 {
1251 }
1253 {
1254 /* Necessary for eg, TEMPLATE_ID_EXPRs (c++/50961). */
1257 }
1258 }
1265 {
1268 /* Tell convert_like that we're using the address. */
1271 }
1272 /* Wrapping a ck_rvalue around a class prvalue (as a result of using
1273 obvalue_p) seems odd, since it's already a prvalue, but that's how we
1274 express the copy constructor call required by copy-initialization. */
1276 {
1278 {
1279 tree bitfield_type;
1282 {
1285 }
1286 }
1288 /* If we're performing copy-initialization, remember to skip
1289 explicit constructors. */
1292 }
1294 /* Allow conversion between `__complex__' data types. */
1296 {
1297 /* The standard conversion sequence to convert FROM to TO is
1298 the standard conversion sequence to perform componentwise
1299 conversion. */
1302 complain);
1308 else
1309 {
1312 }
1315 }
1318 {
1322 }
1324 /* [conv.ptr]
1325 A null pointer constant can be converted to a pointer type; ... A
1326 null pointer constant of integral type can be converted to an
1327 rvalue of type std::nullptr_t. */
1335 {
1336 /* For backwards brain damage compatibility, allow interconversion of
1337 pointers and integers with a pedwarn. */
1340 }
1342 {
1343 /* For backwards brain damage compatibility, allow interconversion of
1344 enums and integers with a pedwarn. */
1347 }
1350 {
1351 tree to_pointee;
1352 tree from_pointee;
1355 {
1359 /* Since this is the target of a pointer, it can't have function
1360 qualifiers, so any TYPE_QUALS must be for attributes const or
1361 noreturn. Strip them. */
1368 }
1369 else
1370 {
1373 }
1377 to_pointee))
1378 ;
1382 {
1384 /* Don't try to apply restrict to void. */
1389 }
1391 {
1398 && (same_type_ignoring_top_level_qualifiers_p
1400 {
1403 }
1404 else
1406 }
1409 /* [conv.ptr]
1411 An rvalue of type "pointer to cv D," where D is a
1412 class type, can be converted to an rvalue of type
1413 "pointer to cv B," where B is a base class (clause
1414 _class.derived_) of D. If B is an inaccessible
1415 (clause _class.access_) or ambiguous
1416 (_class.member.lookup_) base class of D, a program
1417 that necessitates this conversion is ill-formed.
1418 Therefore, we use DERIVED_FROM_P, and do not check
1419 access or uniqueness. */
1421 {
1422 from_pointee
1428 }
1433 /* In a C-style cast, we ignore CV-qualification because we
1434 are allowed to perform a static_cast followed by a
1435 const_cast. */
1440 /* converting from string constant to char *. */
1444 /* Allow conversions among compatible ObjC pointer types (base
1445 conversions have been already handled above). */
1450 {
1453 }
1454 else
1458 }
1460 {
1466 /* If FBASE and TBASE are equivalent but incomplete, DERIVED_FROM_P
1467 yields false. But a pointer to member of incomplete class is OK. */
1476 else
1480 {
1482 tbase,
1488 }
1491 }
1493 {
1494 /* [conv.bool]
1496 A prvalue of arithmetic, unscoped enumeration, pointer, or pointer
1497 to member type can be converted to a prvalue of type bool. ...
1498 For direct-initialization (8.5 [dcl.init]), a prvalue of type
1499 std::nullptr_t can be converted to a prvalue of type bool; */
1505 {
1518 }
1521 }
1522 /* We don't check for ENUMERAL_TYPE here because there are no standard
1523 conversions to enum type. */
1524 /* As an extension, allow conversion to complex type. */
1526 {
1532 /* If we're parsing an enum with no fixed underlying type, we're
1533 dealing with an incomplete type, which renders the conversion
1534 ill-formed. */
1545 /* Give this a better rank if it's a promotion.
1547 To handle CWG 1601, also bump the rank if we are converting
1548 an enumeration with a fixed underlying type to the underlying
1549 type. */
1555 /* A prvalue of floating-point type can be converted to a prvalue of
1556 another floating-point type with a greater or equal conversion
1557 rank ([conv.rank]). A prvalue of standard floating-point type can
1558 be converted to a prvalue of another standard floating-point type.
1559 For backwards compatibility with handling __float128 and other
1560 non-standard floating point types, allow all implicit floating
1561 point conversions if neither type is extended floating-point
1562 type and if at least one of them is, fail if they have unordered
1563 conversion rank or from has higher conversion rank. */
1570 }
1576 {
1580 /* The derived-to-base conversion indicates the initialization
1581 of a parameter with base type from an object of a derived
1582 type. A temporary object is created to hold the result of
1583 the conversion unless we're binding directly to a reference. */
1585 /* If we're performing copy-initialization, remember to skip
1586 explicit constructors. */
1589 }
1590 else
1597 }
1599 /* Returns nonzero if T1 is reference-related to T2. */
1601 bool
1603 {
1610 /* [dcl.init.ref]
1612 Given types "cv1 T1" and "cv2 T2," "cv1 T1" is reference-related
1613 to "cv2 T2" if T1 is similar to T2, or T1 is a base class of T2. */
1617 }
1619 /* Returns nonzero if T1 is reference-compatible with T2. */
1621 bool
1623 {
1624 /* [dcl.init.ref]
1626 "cv1 T1" is reference compatible with "cv2 T2" if
1627 a prvalue of type "pointer to cv2 T2" can be converted to the type
1628 "pointer to cv1 T1" via a standard conversion sequence. */
1636 }
1638 /* Return true if converting FROM to TO would involve a qualification
1639 conversion. */
1641 static bool
1643 {
1644 /* If we're not convering a pointer to another one, we won't get
1645 a qualification conversion. */
1657 }
1659 /* A reference of the indicated TYPE is being bound directly to the
1660 expression represented by the implicit conversion sequence CONV.
1661 Return a conversion sequence for this binding. */
1665 {
1666 tree t;
1674 /* Mark the identity conv as to not decay to rvalue. */
1677 /* [over.ics.rank]
1679 When a parameter of reference type binds directly
1680 (_dcl.init.ref_) to an argument expression, the implicit
1681 conversion sequence is the identity conversion, unless the
1682 argument expression has a type that is a derived class of the
1683 parameter type, in which case the implicit conversion sequence is
1684 a derived-to-base Conversion.
1686 If the parameter binds directly to the result of applying a
1687 conversion function to the argument expression, the implicit
1688 conversion sequence is a user-defined conversion sequence
1689 (_over.ics.user_), with the second standard conversion sequence
1690 either an identity conversion or, if the conversion function
1691 returns an entity of a type that is a derived class of the
1692 parameter type, a derived-to-base conversion. */
1694 {
1695 /* Represent the derived-to-base conversion. */
1697 /* We will actually be binding to the base-class subobject in
1698 the derived class, so we mark this conversion appropriately.
1699 That way, convert_like knows not to generate a temporary. */
1701 }
1703 /* Represent the qualification conversion. After DR 2352
1704 #1 and #2 were indistinguishable conversion sequences:
1706 void f(int*); // #1
1707 void f(const int* const &); // #2
1708 void g(int* p) { f(p); }
1710 because the types "int *" and "const int *const" are
1711 reference-related and we were binding both directly and they
1712 had the same rank. To break it up, we add a ck_qual under the
1713 ck_ref_bind so that conversion sequence ranking chooses #1.
1715 We strip_top_quals here which is also what standard_conversion
1716 does. Failure to do so would confuse comp_cv_qual_signature
1717 into thinking that in
1719 void f(const int * const &); // #1
1720 void f(const int *); // #2
1721 int *x;
1722 f(x);
1724 #2 is a better match than #1 even though they're ambiguous (97296). */
1728 }
1730 /* Returns the conversion path from type FROM to reference type TO for
1731 purposes of reference binding. For lvalue binding, either pass a
1732 reference type to FROM or an lvalue expression to EXPR. If the
1733 reference will be bound to a temporary, NEED_TEMPORARY_P is set for
1734 the conversion returned. If C_CAST_P is true, this
1735 conversion is coming from a C-style cast. */
1739 tsubst_flags_t complain)
1740 {
1745 tree tfrom;
1748 cp_lvalue_kind gl_kind;
1752 {
1757 }
1761 {
1763 /* DR 1288: Otherwise, if the initializer list has a single element
1764 of type E and ... [T's] referenced type is reference-related to E,
1765 the object or reference is initialized from that element...
1767 ??? With P0388R4, we should bind 't' directly to U{}:
1768 using U = A[2];
1769 A (&&t)[] = {U{}};
1770 because A[] and A[2] are reference-related. But we don't do it
1771 because grok_reference_init has deduced the array size (to 1), and
1772 A[1] and A[2] aren't reference-related. */
1775 {
1781 {
1785 }
1786 }
1787 /* Otherwise, if T is a reference type, a prvalue temporary of the type
1788 referenced by T is copy-list-initialized, and the reference is bound
1789 to that temporary. */
1791 skip:;
1792 }
1795 {
1800 else
1802 }
1808 else
1811 /* Don't allow a class prvalue when LOOKUP_NO_TEMP_BIND. */
1816 /* Same mask as real_lvalue_p. */
1823 /* Figure out whether or not the types are reference-related and
1824 reference compatible. We have to do this after stripping
1825 references from FROM. */
1827 /* If this is a C cast, first convert to an appropriately qualified
1828 type, so that we can later do a const_cast to the desired type. */
1834 /* Directly bind reference when target expression's type is compatible with
1835 the reference and expression is an lvalue. In DR391, the wording in
1836 [8.5.3/5 dcl.init.ref] is changed to also require direct bindings for
1837 const and rvalue references to rvalues of compatible class type.
1838 We should also do direct bindings for non-class xvalues. */
1840 {
1841 /* [dcl.init.ref]
1843 If the initializer expression
1845 -- is an lvalue (but not an lvalue for a bit-field), and "cv1 T1"
1846 is reference-compatible with "cv2 T2,"
1848 the reference is bound directly to the initializer expression
1849 lvalue.
1851 [...]
1852 If the initializer expression is an rvalue, with T2 a class type,
1853 and "cv1 T1" is reference-compatible with "cv2 T2", the reference
1854 is bound to the object represented by the rvalue or to a sub-object
1855 within that object. */
1861 /* Handle rvalue reference to function properly. */
1862 conv->rvaluedness_matches_p
1864 else
1865 conv->rvaluedness_matches_p
1870 /* For the purposes of overload resolution, we ignore the fact
1871 this expression is a bitfield or packed field. (In particular,
1872 [over.ics.ref] says specifically that a function with a
1873 non-const reference parameter is viable even if the
1874 argument is a bitfield.)
1876 However, when we actually call the function we must create
1877 a temporary to which to bind the reference. If the
1878 reference is volatile, or isn't const, then we cannot make
1879 a temporary, so we just issue an error when the conversion
1880 actually occurs. */
1883 /* Don't allow binding of lvalues (other than function lvalues) to
1884 rvalue references. */
1889 /* Nor the reverse. */
1891 /* Unless it's really a C++20 lvalue being treated as an xvalue.
1892 But in C++23, such an expression is just an xvalue, not a special
1893 lvalue, so the binding is once again ill-formed. */
1905 }
1906 /* [class.conv.fct] A conversion function is never used to convert a
1907 (possibly cv-qualified) object to the (possibly cv-qualified) same
1908 object type (or a reference to it), to a (possibly cv-qualified) base
1909 class of that type (or a reference to it).... */
1912 {
1913 /* [dcl.init.ref]
1915 If the initializer expression
1917 -- has a class type (i.e., T2 is a class type) can be
1918 implicitly converted to an lvalue of type "cv3 T3," where
1919 "cv1 T1" is reference-compatible with "cv3 T3". (this
1920 conversion is selected by enumerating the applicable
1921 conversion functions (_over.match.ref_) and choosing the
1922 best one through overload resolution. (_over.match_).
1924 the reference is bound to the lvalue result of the conversion
1925 in the second case. */
1927 complain);
1929 {
1933 /* Direct reference binding wasn't successful and yielded a bad
1934 conversion. Proceed with trying to go through a temporary
1935 instead, and if that also fails then we'll return this bad
1936 conversion rather than no conversion for sake of better
1937 diagnostics. */
1939 }
1940 }
1942 /* From this point on, we conceptually need temporaries, even if we
1943 elide them. Only the cases above are "direct bindings". */
1947 /* [over.ics.rank]
1949 When a parameter of reference type is not bound directly to an
1950 argument expression, the conversion sequence is the one required
1951 to convert the argument expression to the underlying type of the
1952 reference according to _over.best.ics_. Conceptually, this
1953 conversion sequence corresponds to copy-initializing a temporary
1954 of the underlying type with the argument expression. Any
1955 difference in top-level cv-qualification is subsumed by the
1956 initialization itself and does not constitute a conversion. */
1960 /* [dcl.init.ref]
1962 Otherwise, the reference shall be an lvalue reference to a
1963 non-volatile const type, or the reference shall be an rvalue
1964 reference. */
1968 /* [dcl.init.ref]
1970 Otherwise, a temporary of type "cv1 T1" is created and
1971 initialized from the initializer expression using the rules for a
1972 non-reference copy initialization. If T1 is reference-related to
1973 T2, cv1 must be the same cv-qualification as, or greater
1974 cv-qualification than, cv2; otherwise, the program is ill-formed. */
1978 /* We try below to treat an invalid reference binding as a bad conversion
1979 to improve diagnostics, but doing so may cause otherwise unnecessary
1980 instantiations that can lead to a hard error. So during the first pass
1981 of overload resolution wherein we shortcut bad conversions, instead just
1982 produce a special conversion indicating a second pass is necessary if
1983 there's no strictly viable candidate. */
1985 {
1992 }
1994 /* We're generating a temporary now, but don't bind any more in the
1995 conversion (specifically, don't slice the temporary returned by a
1996 conversion operator). */
1999 /* Core issue 899: When [copy-]initializing a temporary to be bound
2000 to the first parameter of a copy constructor (12.8) called with
2001 a single argument in the context of direct-initialization,
2002 explicit conversion functions are also considered.
2004 So don't set LOOKUP_ONLYCONVERTING in that case. */
2015 {
2017 /* Remember this was copy-list-initialization. */
2020 /* If initializing the temporary used a conversion function,
2021 recalculate the second conversion sequence. */
2025 {
2027 /* A prvalue of non-class type is cv-unqualified. */
2031 conversion *new_second
2039 }
2040 }
2043 /* This reference binding, unlike those above, requires the
2044 creation of a temporary. */
2050 }
2052 /* Returns the implicit conversion sequence (see [over.ics]) from type
2053 FROM to type TO. The optional expression EXPR may affect the
2054 conversion. FLAGS are the usual overloading flags. If C_CAST_P is
2055 true, this conversion is coming from a C-style cast. */
2060 {
2067 /* Other flags only apply to the primary function in overload
2068 resolution, or after we've chosen one. */
2073 /* FIXME: actually we don't want warnings either, but we can't just
2074 have 'complain &= ~(tf_warning|tf_error)' because it would cause
2075 the regression of, eg, g++.old-deja/g++.benjamin/16077.C.
2076 We really ought not to issue that warning until we've committed
2077 to that conversion. */
2080 /* Call reshape_init early to remove redundant braces. */
2082 {
2087 {
2092 }
2093 }
2097 else
2104 {
2108 /* As an extension, allow list-initialization of _Complex. */
2111 {
2115 }
2117 /* Allow conversion from an initializer-list with one element to a
2118 scalar type. */
2120 {
2122 tree elt;
2128 else
2134 {
2137 /* Too many levels of braces, i.e. '{{1}}'. */
2140 }
2141 }
2144 }
2150 {
2160 {
2165 {
2166 /* "If C is not an initializer-list constructor and the
2167 initializer list has a single element of type cv U, where U is
2168 X or a class derived from X, the implicit conversion sequence
2169 has Exact Match rank if U is X, or Conversion rank if U is
2170 derived from X." */
2176 }
2178 }
2180 /* We used to try to bind a reference to a temporary here, but that
2181 is now handled after the recursive call to this function at the end
2182 of reference_binding. */
2184 }
2187 }
2189 /* Like implicit_conversion, but return NULL if the conversion is bad.
2191 This is not static so that check_non_deducible_conversion can call it within
2192 add_template_candidate_real as part of overload resolution; it should not be
2193 called outside of overload resolution. */
2195 conversion *
2198 {
2204 }
2206 /* Add a new entry to the list of candidates. Used by the add_*_candidate
2207 functions. ARGS will not be changed until a single candidate is
2208 selected. */
2217 {
2235 /* Swap the conversions for comparison in joust; we'll swap them back
2236 before build_over_call. */
2240 }
2242 /* FN is a function from the overload set that we outright didn't even
2243 consider (for some reason); add it to the list as an non-viable "ignored"
2244 candidate. */
2248 {
2249 /* No need to dynamically allocate these. */
2261 }
2263 /* True iff CAND is a candidate added by add_ignored_candidate. */
2265 static bool
2267 {
2269 }
2271 /* Return the number of remaining arguments in the parameter list
2272 beginning with ARG. */
2274 int
2276 {
2281 n++;
2284 }
2286 /* [over.match.copy]: When initializing a temporary object (12.2) to be bound
2287 to the first parameter of a constructor where the parameter is of type
2288 "reference to possibly cv-qualified T" and the constructor is called with a
2289 single argument in the context of direct-initialization of an object of type
2290 "cv2 T", explicit conversion functions are also considered.
2292 So set LOOKUP_COPY_PARM to let reference_binding know that
2293 it's being called in that context. */
2295 int
2297 {
2299 tree t;
2302 && (same_type_ignoring_top_level_qualifiers_p
2304 {
2310 }
2311 else
2315 }
2317 /* Build an appropriate 'this' conversion for the method FN and class
2318 type CTYPE from the value ARG (having type ARGTYPE) to the type PARMTYPE.
2319 This function modifies PARMTYPE, ARGTYPE and ARG. */
2325 {
2329 /* The type of the implicit object parameter ('this') for
2330 overload resolution is not always the same as for the
2331 function itself; conversion functions are considered to
2332 be members of the class being converted, and functions
2333 introduced by a using-declaration are considered to be
2334 members of the class that uses them.
2336 Since build_over_call ignores the ICS for the `this'
2337 parameter, we can just change the parm type. */
2342 {
2343 /* If the function has a ref-qualifier, the implicit
2344 object parameter has reference type. */
2347 /* The special handling of 'this' conversions in compare_ics
2348 does not apply if there is a ref-qualifier. */
2350 }
2351 else
2352 {
2354 /* We don't use build_this here because we don't want to
2355 capture the object argument until we've chosen a
2356 non-static member function. */
2359 }
2365 }
2367 /* Create an overload candidate for the function or method FN called
2368 with the argument list FIRST_ARG/ARGS and add it to CANDIDATES.
2369 FLAGS is passed on to implicit_conversion.
2371 This does not change ARGS.
2373 CTYPE, if non-NULL, is the type we want to pretend this function
2374 comes from for purposes of overload resolution.
2376 SHORTCUT_BAD_CONVS controls how we handle "bad" argument conversions.
2377 If true, we stop computing conversions upon seeing the first bad
2378 conversion. This is used by add_candidates to avoid computing
2379 more conversions than necessary in the presence of a strictly viable
2380 candidate, while preserving the defacto behavior of overload resolution
2381 when it turns out there are only non-strictly viable candidates. */
2390 tsubst_flags_t complain)
2391 {
2394 tree parmnode;
2400 /* The `this', `in_chrg' and VTT arguments to constructors are not
2401 considered in overload resolution. */
2403 {
2405 /* Bring back parameters omitted from an inherited ctor. */
2407 else
2411 {
2414 }
2415 }
2416 else
2423 /* 13.3.2 - Viable functions [over.match.viable]
2424 First, to be a viable function, a candidate function shall have enough
2425 parameters to agree in number with the arguments in the list.
2427 We need to check this first; otherwise, checking the ICSes might cause
2428 us to produce an ill-formed template instantiation. */
2432 {
2436 }
2440 {
2444 }
2446 /* An inherited constructor (12.6.3 [class.inhctor.init]) that has a first
2447 parameter of type "reference to cv C" (including such a constructor
2448 instantiated from a template) is excluded from the set of candidate
2449 functions when used to construct an object of type D with an argument list
2450 containing a single argument if C is reference-related to D. */
2452 && flag_new_inheriting_ctors
2454 {
2460 {
2463 }
2464 }
2466 /* Second, for a function to be viable, its constraints must be
2467 satisfied. */
2469 {
2472 }
2474 /* When looking for a function from a subobject from an implicit
2475 copy/move constructor/operator=, don't consider anything that takes (a
2476 reference to) an unrelated type. See c++/44909 and core 1092. */
2478 {
2484 else
2487 {
2490 ctype))
2492 }
2494 /* This only applies at the top level. */
2496 }
2503 else
2506 /* Third, for F to be a viable function, there shall exist for each
2507 argument an implicit conversion sequence that converts that argument
2508 to the corresponding parameter of F. */
2513 {
2515 tree arg;
2521 {
2522 /* Already set during deduction. */
2525 }
2529 else
2536 {
2543 else
2544 {
2548 }
2551 }
2552 else
2553 {
2557 }
2561 {
2566 }
2569 {
2575 }
2576 }
2578 out:
2581 }
2583 /* Create an overload candidate for the conversion function FN which will
2584 be invoked for expression OBJ, producing a pointer-to-function which
2585 will in turn be called with the argument list FIRST_ARG/ARGLIST,
2586 and add it to CANDIDATES. This does not change ARGLIST. FLAGS is
2587 passed on to implicit_conversion.
2589 Actually, we don't really care about FN; we care about the type it
2590 converts to. There may be multiple conversion functions that will
2591 convert to that type, and we rely on build_user_type_conversion_1 to
2592 choose the best one; so when we create our candidate, we record the type
2593 instead of the function. */
2599 tsubst_flags_t complain)
2600 {
2618 /* Don't bother looking up the same type twice. */
2623 {
2628 }
2631 {
2637 else
2642 {
2645 /* Leave the 'cand' field null; we'll figure out the conversion in
2646 convert_like if this candidate is chosen. */
2648 }
2652 {
2656 }
2657 else
2658 {
2662 }
2669 {
2673 }
2680 }
2684 {
2688 }
2692 }
2694 static void
2698 {
2712 /* TRUTH_*_EXPR do "contextual conversion to bool", which means explicit
2713 conversion ops are allowed. We handle that here by just checking for
2714 boolean_type_node because other operators don't ask for it. COND_EXPR
2715 also does contextual conversion to bool for the first operand, but we
2716 handle that in build_conditional_expr, and type1 here is operand 2. */
2721 {
2725 {
2727 /* We need something for printing the candidate. */
2731 }
2733 {
2738 }
2740 }
2742 /* For COND_EXPR we rearranged the arguments; undo that now. */
2744 {
2749 complain);
2752 else
2753 {
2756 boolean_type_node,
2758 }
2759 }
2766 }
2768 static bool
2770 {
2772 }
2774 /* Returns nonzero if TYPE is a promoted arithmetic type. */
2776 static bool
2778 {
2779 /* [over.built]
2781 In this section, the term promoted integral type is used to refer
2782 to those integral types which are preserved by integral promotion
2783 (including e.g. int and long but excluding e.g. char).
2784 Similarly, the term promoted arithmetic type refers to promoted
2785 integral types plus floating types. */
2789 }
2791 /* Create any builtin operator overload candidates for the operator in
2792 question given the converted operand types TYPE1 and TYPE2. The other
2793 args are passed through from add_builtin_candidates to
2794 build_builtin_candidate.
2796 TYPE1 and TYPE2 may not be permissible, and we must filter them.
2797 If CODE is requires candidates operands of the same type of the kind
2798 of which TYPE1 and TYPE2 are, we add both candidates
2799 CODE (TYPE1, TYPE1) and CODE (TYPE2, TYPE2). */
2801 static void
2806 {
2808 {
2816 }
2819 {
2821 /* 4 For every pair (T, VQ), where T is an arithmetic type other than bool,
2822 and VQ is either volatile or empty, there exist candidate operator
2823 functions of the form
2824 VQ T& operator++(VQ T&);
2825 T operator++(VQ T&, int);
2826 5 For every pair (T, VQ), where T is an arithmetic type other than bool,
2827 and VQ is either volatile or empty, there exist candidate operator
2828 functions of the form
2829 VQ T& operator--(VQ T&);
2830 T operator--(VQ T&, int);
2831 6 For every pair (T, VQ), where T is a cv-qualified or cv-unqualified object
2832 type, and VQ is either volatile or empty, there exist candidate operator
2833 functions of the form
2834 T*VQ& operator++(T*VQ&);
2835 T*VQ& operator--(T*VQ&);
2836 T* operator++(T*VQ&, int);
2837 T* operator--(T*VQ&, int); */
2843 /* FALLTHRU */
2846 /* P0002R1, Remove deprecated operator++(bool) added "other than bool"
2847 to p4. */
2851 {
2854 }
2857 /* 7 For every cv-qualified or cv-unqualified object type T, there
2858 exist candidate operator functions of the form
2860 T& operator*(T*);
2863 8 For every function type T that does not have cv-qualifiers or
2864 a ref-qualifier, there exist candidate operator functions of the form
2865 T& operator*(T*); */
2874 /* 9 For every type T, there exist candidate operator functions of the form
2875 T* operator+(T*);
2877 10 For every floating-point or promoted integral type T, there exist
2878 candidate operator functions of the form
2879 T operator+(T);
2880 T operator-(T); */
2885 /* FALLTHRU */
2891 /* 11 For every promoted integral type T, there exist candidate operator
2892 functions of the form
2893 T operator~(T); */
2900 /* 12 For every quintuple (C1, C2, T, CV1, CV2), where C2 is a class type, C1
2901 is the same type as C2 or is a derived class of C2, and T is an object
2902 type or a function type there exist candidate operator functions of the
2903 form
2904 CV12 T& operator->*(CV1 C1*, CV2 T C2::*);
2905 where CV12 is the union of CV1 and CV2. */
2909 {
2917 }
2920 /* 13 For every pair of types L and R, where each of L and R is a floating-point
2921 or promoted integral type, there exist candidate operator functions of the
2922 form
2923 LR operator*(L, R);
2924 LR operator/(L, R);
2925 LR operator+(L, R);
2926 LR operator-(L, R);
2927 bool operator<(L, R);
2928 bool operator>(L, R);
2929 bool operator<=(L, R);
2930 bool operator>=(L, R);
2931 bool operator==(L, R);
2932 bool operator!=(L, R);
2933 where LR is the result of the usual arithmetic conversions between
2934 types L and R.
2936 14 For every integral type T there exists a candidate operator function of
2937 the form
2939 std::strong_ordering operator<=>(T, T);
2941 15 For every pair of floating-point types L and R, there exists a candidate
2942 operator function of the form
2944 std::partial_ordering operator<=>(L, R);
2946 16 For every cv-qualified or cv-unqualified object type T there exist
2947 candidate operator functions of the form
2948 T* operator+(T*, std::ptrdiff_t);
2949 T& operator[](T*, std::ptrdiff_t);
2950 T* operator-(T*, std::ptrdiff_t);
2951 T* operator+(std::ptrdiff_t, T*);
2952 T& operator[](std::ptrdiff_t, T*);
2954 17 For every T, where T is a pointer to object type, there exist candidate
2955 operator functions of the form
2956 std::ptrdiff_t operator-(T, T);
2958 18 For every T, where T is an enumeration type or a pointer type, there
2959 exist candidate operator functions of the form
2960 bool operator<(T, T);
2961 bool operator>(T, T);
2962 bool operator<=(T, T);
2963 bool operator>=(T, T);
2964 bool operator==(T, T);
2965 bool operator!=(T, T);
2966 R operator<=>(T, T);
2968 where R is the result type specified in [expr.spaceship].
2970 19 For every T, where T is a pointer-to-member type or std::nullptr_t,
2971 there exist candidate operator functions of the form
2972 bool operator==(T, T);
2973 bool operator!=(T, T); */
2980 {
2983 }
2984 /* FALLTHRU */
2991 /* This isn't exactly what's specified above for operator<=>, but it's
2992 close enough. In particular, we don't care about the return type
2993 specified above; it doesn't participate in overload resolution and it
2994 doesn't affect the semantics of the built-in operator. */
3004 {
3007 }
3009 {
3012 }
3013 /* Fall through. */
3029 {
3032 }
3035 {
3038 }
3044 /* FALLTHRU */
3047 {
3050 }
3052 {
3055 }
3058 /* 18For every pair of promoted integral types L and R, there exist candi-
3059 date operator functions of the form
3060 LR operator%(L, R);
3061 LR operator&(L, R);
3062 LR operator^(L, R);
3063 LR operator|(L, R);
3064 L operator<<(L, R);
3065 L operator>>(L, R);
3066 where LR is the result of the usual arithmetic conversions between
3067 types L and R. */
3075 if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type1) && INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type2))
3079 /* 19For every triple L, VQ, R), where L is an arithmetic or enumeration
3080 type, VQ is either volatile or empty, and R is a promoted arithmetic
3081 type, there exist candidate operator functions of the form
3082 VQ L& operator=(VQ L&, R);
3083 VQ L& operator*=(VQ L&, R);
3084 VQ L& operator/=(VQ L&, R);
3085 VQ L& operator+=(VQ L&, R);
3086 VQ L& operator-=(VQ L&, R);
3088 20For every pair T, VQ), where T is any type and VQ is either volatile
3089 or empty, there exist candidate operator functions of the form
3090 T*VQ& operator=(T*VQ&, T*);
3092 21For every pair T, VQ), where T is a pointer to member type and VQ is
3093 either volatile or empty, there exist candidate operator functions of
3094 the form
3095 VQ T& operator=(VQ T&, T);
3097 22For every triple T, VQ, I), where T is a cv-qualified or cv-
3098 unqualified complete object type, VQ is either volatile or empty, and
3099 I is a promoted integral type, there exist candidate operator func-
3100 tions of the form
3101 T*VQ& operator+=(T*VQ&, I);
3102 T*VQ& operator-=(T*VQ&, I);
3104 23For every triple L, VQ, R), where L is an integral or enumeration
3105 type, VQ is either volatile or empty, and R is a promoted integral
3106 type, there exist candidate operator functions of the form
3108 VQ L& operator%=(VQ L&, R);
3109 VQ L& operator<<=(VQ L&, R);
3110 VQ L& operator>>=(VQ L&, R);
3111 VQ L& operator&=(VQ L&, R);
3112 VQ L& operator^=(VQ L&, R);
3113 VQ L& operator|=(VQ L&, R); */
3117 {
3121 {
3124 }
3125 /* FALLTHRU */
3138 if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type1) && INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type2))
3151 {
3154 }
3159 }
3164 /* [over.built]
3166 For every pair of promoted arithmetic types L and R, there
3167 exist candidate operator functions of the form
3169 LR operator?(bool, L, R);
3171 where LR is the result of the usual arithmetic conversions
3172 between types L and R.
3174 For every type T, where T is a pointer or pointer-to-member
3175 type, there exist candidate operator functions of the form T
3176 operator?(bool, T, T); */
3180 /* That's OK. */
3183 /* Otherwise, the types should be pointers. */
3187 /* We don't check that the two types are the same; the logic
3188 below will actually create two candidates; one in which both
3189 parameter types are TYPE1, and one in which both parameter
3190 types are TYPE2. */
3201 }
3203 /* Make sure we don't create builtin candidates with dependent types. */
3207 {
3208 /* Try to recover if one of the types is non-dependent. But if
3209 there's only one type, there's nothing we can do. */
3212 /* And we lose if both are dependent. */
3215 /* Or if they have different forms. */
3223 }
3225 /* If we're dealing with two pointer types or two enumeral types,
3226 we need candidates for both of them. */
3235 {
3237 {
3240 error_mark_node,
3241 error_mark_node,
3242 CPO_CONVERSION,
3243 tf_none);
3245 {
3246 build_builtin_candidate
3250 }
3251 }
3253 build_builtin_candidate
3255 build_builtin_candidate
3258 }
3260 build_builtin_candidate
3262 }
3264 tree
3266 {
3272 }
3274 /* There are three conditions of builtin candidates:
3276 1) bool-taking candidates. These are the same regardless of the input.
3277 2) pointer-pair taking candidates. These are generated for each type
3278 one of the input types converts to.
3279 3) arithmetic candidates. According to the standard, we should generate
3280 all of these, but I'm trying not to...
3282 Here we generate a superset of the possible candidates for this particular
3283 case. That is a subset of the full set the standard defines, plus some
3284 other cases which the standard disallows. add_builtin_candidate will
3285 filter out the invalid set. */
3287 static void
3292 {
3296 /* TYPES[i] is the set of possible builtin-operator parameter types
3297 we will consider for the Ith argument. */
3304 {
3307 else
3309 }
3312 {
3313 /* 4 For every pair T, VQ), where T is an arithmetic or enumeration type,
3314 and VQ is either volatile or empty, there exist candidate operator
3315 functions of the form
3316 VQ T& operator++(VQ T&); */
3326 /* 24There also exist candidate operator functions of the form
3327 bool operator!(bool);
3328 bool operator&&(bool, bool);
3329 bool operator||(bool, bool); */
3332 build_builtin_candidate
3339 build_builtin_candidate
3359 /* Fall through. */
3363 }
3371 {
3373 {
3374 tree convs;
3382 {
3387 }
3393 {
3406 {
3412 }
3416 }
3417 }
3418 else
3419 {
3424 {
3430 }
3432 }
3433 }
3435 /* Run through the possible parameter types of both arguments,
3436 creating candidates with those parameter types. */
3438 {
3440 tree u;
3444 add_builtin_candidate
3447 else
3448 add_builtin_candidate
3451 }
3455 }
3458 /* If TMPL can be successfully instantiated as indicated by
3459 EXPLICIT_TARGS and ARGLIST, adds the instantiation to CANDIDATES.
3461 TMPL is the template. EXPLICIT_TARGS are any explicit template
3462 arguments. ARGLIST is the arguments provided at the call-site.
3463 This does not change ARGLIST. The RETURN_TYPE is the desired type
3464 for conversion operators. If OBJ is NULL_TREE, FLAGS and CTYPE are
3465 as for add_function_candidate. If an OBJ is supplied, FLAGS and
3466 CTYPE are ignored, and OBJ is as for add_conv_candidate.
3468 SHORTCUT_BAD_CONVS is as in add_function_candidate. */
3477 {
3487 tree arg;
3489 tree fn;
3494 /* We don't do deduction on the in-charge parameter, the VTT
3495 parameter or 'this'. */
3497 {
3501 /* We're deducing for a call to the result of a template conversion
3503 else
3505 }
3510 {
3513 else
3515 }
3523 {
3524 /* 12.8/6 says, "A declaration of a constructor for a class X is
3525 ill-formed if its first parameter is of type (optionally cv-qualified)
3526 X and either there are no other parameters or else all other
3527 parameters have default arguments. A member function template is never
3528 instantiated to produce such a constructor signature."
3530 So if we're trying to copy an object of the containing class, don't
3531 consider a template constructor that has a first parameter type that
3532 is just a template parameter, as we would deduce a signature that we
3533 would then reject in the code below. */
3535 {
3540 {
3544 }
3545 }
3546 }
3553 {
3556 }
3560 {
3563 }
3567 {
3568 /* Check that there's no obvious arity mismatch before proceeding with
3569 deduction. This avoids substituting explicit template arguments
3570 into the template or e.g. derived-to-base parm/arg unification
3571 (which could result in an error outside the immediate context) when
3572 the resulting candidate would be unviable anyway. */
3577 {
3579 {
3582 }
3584 /* A parameter with a default argument. */
3586 else
3588 }
3590 {
3591 /* Too few arguments. */
3595 }
3597 {
3598 /* Too many arguments. */
3601 }
3608 {
3609 /* Check the 'this' conversion before proceeding with deduction.
3610 This is effectively an extension of the DR 1391 resolution
3611 that we perform in check_non_deducible_conversions, though it's
3612 convenient to do this extra check here instead of there. */
3621 {
3626 }
3627 }
3628 }
3632 args_without_in_chrg,
3633 nargs_without_in_chrg,
3638 {
3639 /* Don't repeat unification later if it already resulted in errors. */
3643 nargs_without_in_chrg,
3645 else
3648 }
3650 /* Now the explicit specifier might have been deduced; check if this
3651 declaration is explicit. If it is and we're ignoring non-converting
3652 constructors, don't add this function to the set of candidates. */
3659 {
3662 ctype))
3663 {
3664 /* We're trying to produce a constructor with a prohibited signature,
3665 as discussed above; handle here any cases we didn't catch then,
3666 such as X(X<T>). */
3669 }
3670 }
3673 /* Aha, this is a conversion function. */
3676 else
3682 /* This situation can occur if a member template of a template
3683 class is specialized. Then, instantiate_template might return
3684 an instantiation of the specialization, in which case the
3685 DECL_TI_TEMPLATE field will point at the original
3686 specialization. For example:
3688 template <class T> struct S { template <class U> void f(U);
3689 template <> void f(int) {}; };
3690 S<double> sd;
3691 sd.f(3);
3693 Here, TMPL will be template <class U> S<double>::f(U).
3694 And, instantiate template will give us the specialization
3695 template <> S<double>::f(int). But, the DECL_TI_TEMPLATE field
3696 for this will point at template <class T> template <> S<T>::f(int),
3697 so that we can find the definition. For the purposes of
3698 overload resolution, however, we want the original TMPL. */
3700 else
3705 fail:
3709 }
3718 tsubst_flags_t complain)
3719 {
3720 return
3725 complain);
3726 }
3728 /* Create an overload candidate for the conversion function template TMPL,
3729 returning RETURN_TYPE, which will be invoked for expression OBJ to produce a
3730 pointer-to-function which will in turn be called with the argument list
3731 ARGLIST, and add it to CANDIDATES. This does not change ARGLIST. FLAGS is
3732 passed on to implicit_conversion. */
3736 tree obj,
3740 {
3741 return
3746 }
3748 /* The CANDS are the set of candidates that were considered for
3749 overload resolution. Sort CANDS so that the strictly viable
3750 candidates appear first, followed by non-strictly viable candidates,
3751 followed by non-viable candidates. Returns the first candidate
3752 in this sorted list. If any of the candidates were viable, set
3753 *ANY_VIABLE_P to true. STRICT_P is true if a candidate should be
3754 considered viable only if it is strictly viable when setting
3755 *ANY_VIABLE_P. */
3761 {
3774 /* Be strict inside templates, since build_over_call won't actually
3775 do the conversions to get pedwarns. */
3780 {
3783 /* Be strict in the presence of a viable candidate. Also if
3784 there are template candidates, so that we get deduction errors
3785 for them instead of silently preferring a bad conversion. */
3788 /* Move this candidate to the appropriate list according to
3789 its viability. */
3796 }
3801 /* Combine the lists. */
3808 }
3810 static bool
3812 {
3817 }
3819 /* OBJ is being used in an expression like "OBJ.f (...)". In other
3820 words, it is about to become the "this" pointer for a member
3821 function call. Take the address of the object. */
3823 static tree
3825 {
3826 /* In a template, we are only concerned about the type of the
3827 expression, so we can take a shortcut. */
3832 }
3834 /* Returns true iff functions are equivalent. Equivalent functions are
3835 not '==' only if one is a function-local extern function or if
3836 both are extern "C". */
3840 {
3849 }
3851 /* Print information about a candidate FN being rejected due to INFO. */
3853 static void
3855 tree fn)
3856 {
3861 {
3862 /* Conversion of implicit `this' argument failed. */
3864 /* A bad conversion for 'this' must be discarding cv-quals. */
3867 from);
3868 else
3872 }
3874 {
3880 tf_warning_or_error);
3881 }
3883 /* Conversion of conversion function return value failed. */
3886 else
3887 {
3892 }
3893 }
3895 /* Print information about a candidate with WANT parameters and we found
3896 HAVE. */
3898 static void
3901 {
3907 else
3912 }
3914 /* Print information about one overload candidate CANDIDATE. MSGSTR
3915 is the text to print before the candidate itself.
3917 NOTE: Unlike most diagnostic functions in GCC, MSGSTR is expected
3918 to have been run through gettext by the caller. This wart makes
3919 life simpler in print_z_candidates and for the translators. */
3921 static void
3924 {
3934 {
3945 else
3948 }
3961 else
3964 {
3967 }
3968 /* Give the user some information about why this candidate failed. */
3970 {
3974 {
3988 "cannot be converted to %qT with a qualification "
3994 "conversion function specialization to %qT is not an "
3999 /* We use template_unification_error_rejection if unification caused
4000 actual non-SFINAE errors, in which case we don't need to repeat
4001 them here. */
4003 {
4007 }
4008 /* Re-run template unification with diagnostics. */
4012 (make_tree_vec
4023 " a constructor taking a single argument of its own "
4031 "initialization from an expression of the same or derived "
4038 /* This candidate didn't have any issues or we failed to
4039 handle a particular code. Either way... */
4041 }
4042 }
4043 }
4045 /* Print information about each overload candidate in CANDIDATES,
4046 which is assumed to have gone through splice_viable and tourney
4047 (if splice_viable succeeded). */
4049 static void
4052 {
4059 /* Remove non-viable deleted candidates. */
4062 {
4067 else
4069 }
4070 /* ...if there are any non-deleted ones. */
4074 /* There may be duplicates in the set of candidates. We put off
4075 checking this condition as long as possible, since we have no way
4076 to eliminate duplicates from a set of functions in less than n^2
4077 time. Now we are about to emit an error message, so it is more
4078 permissible to go slowly. */
4080 {
4082 /* Skip builtin candidates and conversion functions. */
4087 {
4091 else
4093 }
4094 }
4096 /* Unless otherwise specified, if there's a (strictly) viable candidate
4097 then we assume we're being called as part of diagnosing ambiguity, in
4098 which case we want to print only viable candidates since non-viable
4099 candidates couldn't have contributed to the ambiguity. */
4104 {
4108 {
4112 }
4114 }
4115 }
4117 /* USER_SEQ is a user-defined conversion sequence, beginning with a
4118 USER_CONV. STD_SEQ is the standard conversion sequence applied to
4119 the result of the conversion function to convert it to the final
4120 desired type. Merge the two sequences into a single sequence,
4121 and return the merged sequence. */
4125 {
4131 /* Find the end of the second conversion sequence. */
4133 {
4134 /* The entire sequence is a user-conversion sequence. */
4138 }
4141 /* We're binding a reference directly to the result of the conversion.
4142 build_user_type_conversion_1 stripped the REFERENCE_TYPE from the return
4143 type, but we want it back. */
4146 /* Replace the identity conversion with the user conversion
4147 sequence. */
4151 }
4153 /* Handle overload resolution for initializing an object of class type from
4154 an initializer list. First we look for a suitable constructor that
4155 takes a std::initializer_list; if we don't find one, we then look for a
4156 non-list constructor.
4158 Parameters are as for add_candidates, except that the arguments are in
4159 the form of a CONSTRUCTOR (the initializer list) rather than a vector, and
4160 the RETURN_TYPE parameter is replaced by TOTYPE, the desired type. */
4162 static void
4169 tsubst_flags_t complain)
4170 {
4173 /* We're looking for a ctor for list-initialization. */
4175 /* And we don't allow narrowing conversions. We also use this flag to
4176 avoid the copy constructor call for copy-list-initialization. */
4182 /* Always use the default constructor if the list is empty (DR 990). */
4185 ;
4188 {
4193 }
4194 /* If the class has a list ctor, try passing the list as a single
4195 argument first, but only consider list ctors. */
4197 {
4204 }
4206 /* Expand the CONSTRUCTOR into a new argument vec. */
4214 /* We aren't looking for list-ctors anymore. */
4216 /* We allow more user-defined conversions within an init-list. */
4222 }
4224 /* Given C(std::initializer_list<A>), return A. */
4226 static tree
4228 {
4234 }
4236 /* If EXPR is a braced-init-list where the elements all decay to the same type,
4237 return that type. */
4239 static tree
4241 {
4250 {
4257 }
4259 }
4261 /* True iff EXPR contains any temporaries with non-trivial destruction.
4263 ??? Also ignore classes with non-trivial but no-op destruction other than
4264 std::allocator? */
4266 static bool
4268 {
4272 {
4277 }
4279 }
4281 /* We're initializing an array of ELTTYPE from INIT. If it seems useful,
4282 return INIT as an array (of its own type) so the caller can initialize the
4283 target array in a loop. */
4285 static tree
4287 {
4288 /* Only do this if the array can go in rodata but not once converted. */
4295 /* Check with a stub expression to weed out special cases, and check whether
4296 we call the same function for direct-init as copy-list-init. */
4297 conversion_obstack_sentinel cos;
4309 tf_none);
4316 /* Let the normal code give the error. */
4319 /* Don't do this if the conversion would be constant. */
4324 /* We can't do this if the conversion creates temporaries that need
4325 to live until the whole array is initialized. */
4329 /* We can't do this if copying from the initializer_list would be
4330 ill-formed. */
4342 }
4344 /* If we were going to call e.g. vector(initializer_list<string>) starting
4345 with a list of string-literals (which is inefficient, see PR105838),
4346 instead build an array of const char* and pass it to the range constructor.
4347 But only do this for standard library types, where we can assume the
4348 transformation makes sense.
4350 Really the container classes should have initializer_list<U> constructors to
4351 get the same effect more simply; this is working around that lack. */
4353 static tree
4355 {
4360 {
4363 {
4371 }
4372 }
4375 }
4377 /* Returns the best overload candidate to perform the requested
4378 conversion. This function is used for three the overloading situations
4379 described in [over.match.copy], [over.match.conv], and [over.match.ref].
4380 If TOTYPE is a REFERENCE_TYPE, we're trying to find a direct binding as
4381 per [dcl.init.ref], so we ignore temporary bindings. */
4385 tsubst_flags_t complain)
4386 {
4388 tree fromtype;
4402 /* We represent conversion within a hierarchy using RVALUE_CONV and
4403 BASE_CONV, as specified by [over.best.ics]; these become plain
4404 constructor calls, as specified in [dcl.init]. */
4409 /* Use lookup_fnfields_slot instead of lookup_fnfields to avoid
4410 creating a garbage BASELINK; constructors can't be inherited. */
4415 {
4419 {
4420 /* [class.conv.fct] A conversion function is never used to
4421 convert a (possibly cv-qualified) object to the (possibly
4422 cv-qualified) same object type (or a reference to it), to a
4423 (possibly cv-qualified) base class of that type (or a
4424 reference to it)... */
4425 }
4426 else
4428 }
4434 /* Prevent add_candidates from treating a non-strictly viable candidate
4435 as unviable. */
4438 /* It's OK to bind a temporary for converting constructor arguments, but
4439 not in converting the return value of a conversion operator. */
4445 {
4450 /* We should never try to call the abstract or base constructor
4451 from here. */
4457 {
4458 /* List-initialization. */
4462 }
4463 else
4464 {
4468 }
4471 {
4474 /* If totype isn't a reference, and LOOKUP_ONLYCONVERTING is
4475 set, then this is copy-initialization. In that case, "The
4476 result of the call is then used to direct-initialize the
4477 object that is the destination of the copy-initialization."
4478 [dcl.init]
4480 We represent this in the conversion sequence with an
4481 rvalue conversion, which means a constructor call. */
4486 cand->second_conv
4488 }
4489 }
4492 {
4495 else
4497 }
4500 {
4504 /* If LOOKUP_NO_CONVERSION, don't consider a conversion function that
4505 would need an addional user-defined conversion, i.e. if the return
4506 type differs in class-ness from the desired type. So we avoid
4507 considering operator bool when calling a copy constructor.
4509 This optimization avoids the failure in PR97600, and is allowed by
4510 [temp.inst]/9: "If the function selected by overload resolution can be
4511 determined without instantiating a class template definition, it is
4512 unspecified whether that instantiation actually takes place." */
4520 /* If we are called to convert to a reference type, we are trying to
4521 find a direct binding, so don't even consider temporaries. If
4522 we don't find a direct binding, the caller will try again to
4523 look for a temporary binding. */
4534 {
4536 /* Already rejected, don't change to -1. */
4540 conversion *ics
4542 rettype,
4545 complain);
4547 /* If LOOKUP_NO_TEMP_BIND isn't set, then this is
4548 copy-initialization. In that case, "The result of the
4549 call is then used to direct-initialize the object that is
4550 the destination of the copy-initialization." [dcl.init]
4552 We represent this in the conversion sequence with an
4553 rvalue conversion, which means a constructor call. But
4554 don't add a second rvalue conversion if there's already
4555 one there. Which there really shouldn't be, but it's
4556 harmless since we'd add it here anyway. */
4564 {
4569 }
4571 /* Limit this to non-templates for now (PR90546). */
4574 {
4575 /* If we are called to convert to a reference type, we are trying
4576 to find a direct binding per [over.match.ref], so rvaluedness
4577 must match for non-functions. */
4579 }
4582 {
4583 /* 13.3.1.5: For direct-initialization, those explicit
4584 conversion functions that are not hidden within S and
4585 yield type T or a type that can be converted to type T
4586 with a qualification conversion (4.4) are also candidate
4587 functions. */
4588 /* 13.3.1.6 doesn't have a parallel restriction, but it should;
4589 I've raised this issue with the committee. --jason 9/2011 */
4592 }
4594 {
4596 cand->reason
4600 }
4603 {
4604 /* 13.3.3.1.2: If the user-defined conversion is specified by
4605 a specialization of a conversion function template, the
4606 second standard conversion sequence shall have exact match
4607 rank. */
4610 }
4611 }
4612 }
4616 {
4620 }
4624 {
4626 {
4627 auto_diagnostic_group d;
4632 }
4641 /* If there are viable candidates, don't set ICS_BAD_FLAG; an
4642 ambiguous conversion is no worse than another user-defined
4643 conversion. */
4646 }
4648 /* Maybe pass { } as iterators instead of an initializer_list. */
4653 {
4656 }
4658 tree convtype;
4662 /* DR 5: [in the first step of copy-initialization]...if the function
4663 is a constructor, the call initializes a temporary of the
4664 cv-unqualified version of the destination type. */
4666 else
4668 /* Build the user conversion sequence. */
4669 conv = build_conv
4671 convtype,
4677 /* Remember that this was a list-initialization. */
4681 /* Combine it with the second conversion sequence. */
4686 }
4688 /* Wrapper for above. */
4690 tree
4692 tsubst_flags_t complain)
4693 {
4695 tree ret;
4699 conversion_obstack_sentinel cos;
4704 {
4707 else
4708 {
4711 }
4712 }
4713 else
4717 }
4719 /* Give a helpful diagnostic when implicit_conversion fails. */
4721 static void
4723 {
4726 /* If expr has unknown type, then it is an overloaded function.
4727 Call instantiate_type to get good error messages. */
4737 else
4738 {
4743 }
4744 }
4746 /* Worker for build_converted_constant_expr. */
4748 static tree
4751 {
4753 tree t;
4759 conversion_obstack_sentinel cos;
4764 /* A converted constant expression of type T is an expression, implicitly
4765 converted to type T, where the converted expression is a constant
4766 expression and the implicit conversion sequence contains only
4768 * user-defined conversions,
4769 * lvalue-to-rvalue conversions (7.1),
4770 * array-to-pointer conversions (7.2),
4771 * function-to-pointer conversions (7.3),
4772 * qualification conversions (7.5),
4773 * integral promotions (7.6),
4774 * integral conversions (7.8) other than narrowing conversions (11.6.4),
4775 * null pointer conversions (7.11) from std::nullptr_t,
4776 * null member pointer conversions (7.12) from std::nullptr_t, and
4777 * function pointer conversions (7.13),
4779 and where the reference binding (if any) binds directly. */
4784 {
4786 {
4787 /* A conversion function is OK. If it isn't constexpr, we'll
4788 complain later that the argument isn't constant. */
4790 /* List-initialization is OK. */
4792 /* The lvalue-to-rvalue conversion is OK. */
4794 /* Array-to-pointer and function-to-pointer. */
4796 /* Function pointer conversions. */
4798 /* Qualification conversions. */
4804 {
4810 }
4820 /* Integral promotion or conversion. */
4823 /* Conversion from nullptr to pointer or pointer-to-member. */
4829 /* fall through. */
4834 }
4835 }
4837 /* Avoid confusing convert_nontype_argument by introducing
4838 a redundant conversion to the same reference type. */
4841 {
4845 }
4848 {
4849 /* Don't copy a class in a template. */
4854 /* Issuing conversion warnings for value-dependent expressions is
4855 likely too noisy. */
4860 }
4861 else
4862 {
4866 }
4869 }
4871 /* Subroutine of convert_nontype_argument.
4873 EXPR is an expression used in a context that requires a converted
4874 constant-expression, such as a template non-type parameter. Do any
4875 necessary conversions (that are permitted for converted
4876 constant-expressions) to convert it to the desired type.
4878 This function doesn't consider explicit conversion functions. If
4879 you mean to use "a contextually converted constant expression of type
4880 bool", use build_converted_constant_bool_expr.
4882 If conversion is successful, returns the converted expression;
4883 otherwise, returns error_mark_node. */
4885 tree
4887 {
4889 complain);
4890 }
4892 /* Used to create "a contextually converted constant expression of type
4893 bool". This differs from build_converted_constant_expr in that it
4894 also considers explicit conversion functions. */
4896 tree
4898 {
4901 }
4903 /* Do any initial processing on the arguments to a function call. */
4907 {
4909 tree arg;
4912 {
4916 {
4921 }
4925 /* Force auto deduction now. Omit tf_warning to avoid redundant
4926 deprecated warning on deprecated-14.C. */
4929 }
4931 }
4933 /* Perform overload resolution on FN, which is called with the ARGS.
4935 Return the candidate function selected by overload resolution, or
4936 NULL if the event that overload resolution failed. In the case
4937 that overload resolution fails, *CANDIDATES will be the set of
4938 candidates considered, and ANY_VIABLE_P will be set to true or
4939 false to indicate whether or not any of the candidates were
4940 viable.
4942 The ARGS should already have gone through RESOLVE_ARGS before this
4943 function is called. */
4950 {
4952 tree explicit_targs;
4963 /* Check FN. */
4967 {
4971 }
4973 /* Add the various candidate functions. */
4978 LOOKUP_NORMAL,
4984 else
4988 }
4990 /* Print an error message about being unable to build a call to FN with
4991 ARGS. ANY_VIABLE_P indicates whether any candidate functions could
4992 be located; CANDIDATES is a possibly empty list of such
4993 functions. */
4995 static void
4998 {
5001 {
5004 }
5010 auto_diagnostic_group d;
5014 else
5019 }
5021 /* Perform overload resolution on the set of deduction guides DGUIDES
5022 using ARGS. Returns the selected deduction guide, or error_mark_node
5023 if overload resolution fails. */
5025 tree
5027 tsubst_flags_t complain)
5028 {
5031 tree result;
5035 conversion_obstack_sentinel cos;
5040 {
5044 }
5045 else
5049 }
5051 /* Return an expression for a call to FN (a namespace-scope function,
5052 or a static member function) with the ARGS. This may change
5053 ARGS. */
5055 tree
5057 tsubst_flags_t complain)
5058 {
5061 tree result;
5064 {
5068 }
5073 conversion_obstack_sentinel cos;
5076 complain);
5079 {
5081 {
5082 // If there is a single (non-viable) function candidate,
5083 // let the error be diagnosed by cp_build_function_call_vec.
5086 /* A template-id callee consisting of a single (ignored)
5087 non-template candidate needs to be diagnosed the
5088 ordinary way. */
5093 // Otherwise, emit notes for non-viable candidates.
5095 }
5097 }
5098 else
5099 {
5101 }
5104 && result
5111 }
5113 /* Build a call to a global operator new. FNNAME is the name of the
5114 operator (either "operator new" or "operator new[]") and ARGS are
5115 the arguments provided. This may change ARGS. *SIZE points to the
5116 total number of bytes required by the allocation, and is updated if
5117 that is changed here. *COOKIE_SIZE is non-NULL if a cookie should
5118 be used. If this function determines that no cookie should be
5119 used, after all, *COOKIE_SIZE is set to NULL_TREE. If SIZE_CHECK
5120 is not NULL_TREE, it is evaluated before calculating the final
5121 array size, and if it fails, the array size is replaced with
5122 (size_t)-1 (usually triggering a std::bad_alloc exception). If FN
5123 is non-NULL, it will be set, upon return, to the allocation
5124 function called. */
5126 tree
5131 {
5133 tree fns;
5140 /* Set to (size_t)-1 if the size check fails. */
5142 {
5148 }
5154 conversion_obstack_sentinel cos;
5156 /* Based on:
5158 [expr.new]
5160 If this lookup fails to find the name, or if the allocated type
5161 is not a class type, the allocation function's name is looked
5162 up in the global scope.
5164 we disregard block-scope declarations of "operator new". */
5168 {
5175 /* If no aligned allocation function matches, try again without the
5176 alignment. */
5177 }
5179 /* Figure out what function is being called. */
5182 complain);
5184 /* If no suitable function could be found, issue an error message
5185 and give up. */
5187 {
5191 }
5193 /* If a cookie is required, add some extra space. Whether
5194 or not a cookie is required cannot be determined until
5195 after we know which function was called. */
5197 {
5199 tree arg_types;
5202 /* Skip the size_t parameter. */
5204 /* Check the remaining parameters (if any). */
5208 ptr_type_node))
5210 /* If we need a cookie, adjust the number of bytes allocated. */
5212 {
5213 /* Update the total size. */
5216 {
5217 /* Set to (size_t)-1 if the size check fails. */
5221 }
5222 /* Update the argument list to reflect the adjusted size. */
5224 }
5225 else
5227 }
5229 /* Tell our caller which function we decided to call. */
5233 /* Build the CALL_EXPR. */
5236 /* Set this flag for all callers of this function. In addition to
5237 new-expressions, this is called for allocating coroutine state; treat
5238 that as an implicit new-expression. */
5244 }
5246 /* Evaluate side-effects from OBJ before evaluating call
5247 to FN in RESULT expression.
5248 This is for expressions of the form `obj->fn(...)'
5249 where `fn' turns out to be a static member function and
5250 `obj' needs to be evaluated. `fn' could be also static operator[]
5251 or static operator(), in which cases the source expression
5252 would be `obj[...]' or `obj(...)'. */
5254 tree
5256 {
5263 /* But avoid the implicit lvalue-rvalue conversion when `obj' is
5264 volatile. */
5271 }
5273 /* Build a new call to operator(). This may change ARGS. */
5275 tree
5277 {
5295 {
5297 /* It's no good looking for an overloaded operator() on a
5298 pointer-to-member-function. */
5302 }
5305 {
5309 }
5310 else
5314 {
5318 }
5320 conversion_obstack_sentinel cos;
5323 {
5331 }
5338 {
5346 {
5351 {
5352 /* Making this work broke PR 71117 and 85118, so until the
5353 committee resolves core issue 2189, let's disable this
5354 candidate if there are any call operators. */
5358 add_template_conv_candidate
5362 }
5363 else
5367 }
5368 }
5370 /* Be strict here because if we choose a bad conversion candidate, the
5371 errors we get won't mention the call context. */
5374 {
5376 {
5377 auto_diagnostic_group d;
5381 }
5383 }
5384 else
5385 {
5388 {
5390 {
5391 auto_diagnostic_group d;
5395 }
5397 }
5401 {
5403 /* In an expression of the form `a()' where cand->fn
5404 which is operator() turns out to be a static member function,
5405 `a' is none-the-less evaluated. */
5407 }
5408 else
5409 {
5413 else
5414 {
5417 }
5420 }
5421 }
5424 }
5426 /* Called by op_error to prepare format strings suitable for the error
5427 function. It concatenates a prefix (controlled by MATCH), ERRMSG,
5428 and a suffix (controlled by NTYPES). */
5432 {
5442 else
5446 }
5448 static void
5452 {
5457 {
5463 else
5475 else
5485 else
5496 else
5505 else
5514 {
5519 }
5520 else
5525 else
5529 else
5534 }
5535 }
5537 /* Return the implicit conversion sequence that could be used to
5538 convert E1 to E2 in [expr.cond]. */
5542 {
5548 /* [expr.cond]
5550 If E2 is an lvalue: E1 can be converted to match E2 if E1 can be
5551 implicitly converted (clause _conv_) to the type "lvalue reference to
5552 T2", subject to the constraint that in the conversion the
5553 reference must bind directly (_dcl.init.ref_) to an lvalue.
5555 If E2 is an xvalue: E1 can be converted to match E2 if E1 can be
5556 implicitly converted to the type "rvalue reference to T2", subject to
5557 the constraint that the reference must bind directly. */
5559 {
5562 t1,
5563 e1,
5565 LOOKUP_NO_TEMP_BIND|LOOKUP_NO_RVAL_BIND
5567 complain);
5570 }
5572 /* If E2 is a prvalue or if neither of the conversions above can be done
5573 and at least one of the operands has (possibly cv-qualified) class
5574 type: */
5578 /* [expr.cond]
5580 If E1 and E2 have class type, and the underlying class types are
5581 the same or one is a base class of the other: E1 can be converted
5582 to match E2 if the class of T2 is the same type as, or a base
5583 class of, the class of T1, and the cv-qualification of T2 is the
5584 same cv-qualification as, or a greater cv-qualification than, the
5585 cv-qualification of T1. If the conversion is applied, E1 is
5586 changed to an rvalue of type T2 that still refers to the original
5587 source class object (or the appropriate subobject thereof). */
5590 {
5592 {
5597 else
5600 }
5601 else
5603 }
5604 else
5605 /* [expr.cond]
5607 Otherwise: E1 can be converted to match E2 if E1 can be implicitly
5608 converted to the type that expression E2 would have if E2 were
5609 converted to an rvalue (or the type it has, if E2 is an rvalue). */
5612 }
5614 /* Implement [expr.cond]. ARG1, ARG2, and ARG3 are the three
5615 arguments to the conditional expression. */
5617 tree
5620 tsubst_flags_t complain)
5621 {
5622 tree arg2_type;
5623 tree arg3_type;
5634 /* As a G++ extension, the second argument to the conditional can be
5635 omitted. (So that `a ? : c' is roughly equivalent to `a ? a :
5636 c'.) If the second operand is omitted, make sure it is
5637 calculated only once. */
5639 {
5642 "ISO C++ forbids omitting the middle term of "
5648 /* Make sure that lvalues remain lvalues. See g++.oliva/ext1.C. */
5650 {
5653 }
5655 /* arg1 can't be a prvalue result of the conditional
5656 expression, since it needs to be materialized for the
5657 conversion to bool, so treat it as an xvalue in arg2. */
5662 else
5664 }
5666 /* If something has already gone wrong, just pass that fact up the
5667 tree. */
5673 conversion_obstack_sentinel cos;
5680 {
5683 /* If arg1 is another cond_expr choosing between -1 and 0,
5684 then we can use its comparison. It may help to avoid
5685 additional comparison, produce more accurate diagnostics
5686 and enables folding. */
5696 /* force_rvalue can return error_mark on valid arguments. */
5707 {
5708 /* Rely on the error messages of the scalar version. */
5717 {
5725 }
5729 /* We could pass complain & tf_warning to unsafe_conversion_p,
5730 but the warnings (like Wsign-conversion) have already been
5731 given by the scalar build_conditional_expr_1. We still check
5732 unsafe_conversion_p to forbid truncating long long -> float. */
5734 {
5739 }
5741 {
5746 }
5756 }
5760 {
5766 {
5770 {
5776 }
5778 {
5784 }
5787 }
5788 }
5796 {
5799 "incompatible vector types in conditional expression: "
5803 }
5806 {
5809 }
5811 }
5813 /* [expr.cond]
5815 The first expression is implicitly converted to bool (clause
5816 _conv_). */
5818 LOOKUP_NORMAL);
5833 {
5834 semantic_result_type
5837 {
5848 && cp_compare_floating_point_conversion_ranks
5855 }
5857 {
5860 }
5862 {
5865 }
5866 }
5868 /* [expr.cond]
5870 If either the second or the third operand has type (possibly
5871 cv-qualified) void, then the lvalue-to-rvalue (_conv.lval_),
5872 array-to-pointer (_conv.array_), and function-to-pointer
5873 (_conv.func_) standard conversions are performed on the second
5874 and third operands. */
5876 {
5877 /* 'void' won't help in resolving an overloaded expression on the
5878 other side, so require it to resolve by itself. */
5880 {
5883 }
5885 {
5888 }
5890 /* [expr.cond]
5892 One of the following shall hold:
5894 --The second or the third operand (but not both) is a
5895 throw-expression (_except.throw_); the result is of the type
5896 and value category of the other.
5898 --Both the second and the third operands have type void; the
5899 result is of type void and is a prvalue. */
5902 {
5905 }
5908 {
5911 }
5913 {
5916 }
5917 else
5918 {
5920 {
5923 "second operand to the conditional operator "
5924 "is of type %<void%>, but the third operand is "
5926 else
5928 "third operand to the conditional operator "
5929 "is of type %<void%>, but the second operand is "
5931 }
5933 }
5936 }
5937 /* [expr.cond]
5939 Otherwise, if the second and third operand have different types,
5940 and either has (possibly cv-qualified) class type, or if both are
5941 glvalues of the same value category and the same type except for
5942 cv-qualification, an attempt is made to convert each of those operands
5943 to the type of the other. */
5947 arg3_type)
5950 {
5958 /* [expr.cond]
5960 If both can be converted, or one can be converted but the
5961 conversion is ambiguous, the program is ill-formed. If
5962 neither can be converted, the operands are left unchanged and
5963 further checking is performed as described below. If exactly
5964 one conversion is possible, that conversion is applied to the
5965 chosen operand and the converted operand is used in place of
5966 the original operand for the remainder of this section. */
5971 {
5973 {
5981 else
5983 }
5985 }
5987 {
5991 /* Even if CONV2 is a valid conversion, the result of the
5992 conversion may be invalid. For example, if ARG3 has type
5993 "volatile X", and X does not have a copy constructor
5994 accepting a "volatile X&", then even if ARG2 can be
5995 converted to X, the conversion will fail. */
5999 }
6001 {
6008 }
6013 /* If, after the conversion, both operands have class type,
6014 treat the cv-qualification of both operands as if it were the
6015 union of the cv-qualification of the operands.
6017 The standard is not clear about what to do in this
6018 circumstance. For example, if the first operand has type
6019 "const X" and the second operand has a user-defined
6020 conversion to "volatile X", what is the type of the second
6021 operand after this step? Making it be "const X" (matching
6022 the first operand) seems wrong, as that discards the
6023 qualification without actually performing a copy. Leaving it
6024 as "volatile X" seems wrong as that will result in the
6025 conditional expression failing altogether, even though,
6026 according to this step, the one operand could be converted to
6027 the type of the other. */
6035 }
6037 /* [expr.cond]
6039 If the second and third operands are glvalues of the same value
6040 category and have the same type, the result is of that type and
6041 value category. */
6045 {
6048 }
6050 /* [expr.cond]
6052 Otherwise, the result is an rvalue. If the second and third
6053 operand do not have the same type, and either has (possibly
6054 cv-qualified) class type, overload resolution is used to
6055 determine the conversions (if any) to be applied to the operands
6056 (_over.match.oper_, _over.built_). */
6060 {
6061 releasing_vec args;
6065 /* Rearrange the arguments so that add_builtin_candidate only has
6066 to know about two args. In build_builtin_candidate, the
6067 arguments are unscrambled. */
6072 COND_EXPR,
6073 NOP_EXPR,
6075 args,
6078 /* [expr.cond]
6080 If the overload resolution fails, the program is
6081 ill-formed. */
6084 {
6089 }
6092 {
6094 {
6095 auto_diagnostic_group d;
6098 }
6100 }
6102 /* [expr.cond]
6104 Otherwise, the conversions thus determined are applied, and
6105 the converted operands are used in place of the original
6106 operands for the remainder of this section. */
6115 }
6117 /* [expr.cond]
6119 Lvalue-to-rvalue (_conv.lval_), array-to-pointer (_conv.array_),
6120 and function-to-pointer (_conv.func_) standard conversions are
6121 performed on the second and third operands.
6123 We need to force the lvalue-to-rvalue conversion here for class types,
6124 so we get TARGET_EXPRs; trying to deal with a COND_EXPR of class rvalues
6125 that isn't wrapped with a TARGET_EXPR plays havoc with exception
6126 regions. */
6139 /* [expr.cond]
6141 After those conversions, one of the following shall hold:
6143 --The second and third operands have the same type; the result is of
6144 that type. */
6147 /* [expr.cond]
6149 --The second and third operands have arithmetic or enumeration
6150 type; the usual arithmetic conversions are performed to bring
6151 them to a common type, and the result is of that type. */
6156 {
6157 /* A conditional expression between a floating-point
6158 type and an integer type should convert the integer type to
6159 the evaluation format of the floating-point type, with
6160 possible excess precision. */
6163 tree eptype;
6166 {
6169 semantic_result_type
6171 }
6174 {
6177 semantic_result_type
6179 }
6181 eptype3);
6183 {
6194 && cp_compare_floating_point_conversion_ranks
6201 }
6203 {
6214 && cp_compare_floating_point_conversion_ranks
6221 }
6225 "implicit conversion from %qH to %qI to "
6227 loc);
6231 {
6238 /* Two enumerators from the same enumeration can have different
6248 }
6258 {
6263 "conditional expression between enumeration type "
6267 "conditional expression between floating-point type "
6271 "conditional expression between enumeration type "
6274 else
6276 "conditional expression between floating-point "
6279 }
6286 {
6288 {
6290 ? OPT_Wenum_conversion
6294 }
6295 }
6299 }
6300 /* [expr.cond]
6302 --The second and third operands have pointer type, or one has
6303 pointer type and the other is a null pointer constant; pointer
6304 conversions (_conv.ptr_) and qualification conversions
6305 (_conv.qual_) are performed to bring them to their composite
6306 pointer type (_expr.rel_). The result is of the composite
6307 pointer type.
6309 --The second and third operands have pointer to member type, or
6310 one has pointer to member type and the other is a null pointer
6311 constant; pointer to member conversions (_conv.mem_) and
6312 qualification conversions (_conv.qual_) are performed to bring
6313 them to a common type, whose cv-qualification shall match the
6314 cv-qualification of either the second or the third operand.
6315 The result is of the common type. */
6323 {
6327 complain);
6332 }
6335 {
6340 }
6345 valid_operands:
6347 {
6348 /* Let lvalue_kind know this was a glvalue. */
6351 }
6355 /* If the ARG2 and ARG3 are the same and don't have side-effects,
6356 warn here, because the COND_EXPR will be turned into ARG2. */
6360 OEP_ADDRESS_OF_SAME_FIELD)))
6364 /* We can't use result_type below, as fold might have returned a
6365 throw_expr. */
6368 {
6369 /* Expand both sides into the same slot, hopefully the target of
6370 the ?: expression. We used to check for TARGET_EXPRs here,
6371 but now we sometimes wrap them in NOP_EXPRs so the test would
6372 fail. */
6374 {
6376 /* Tell gimplify_modify_expr_rhs not to strip this in
6377 assignment context: we want both arms to initialize
6378 the same temporary. */
6380 }
6381 /* If this expression is an rvalue, but might be mistaken for an
6382 lvalue, we must add a NON_LVALUE_EXPR. */
6386 result);
6387 }
6388 else
6389 {
6392 }
6395 }
6397 /* OPERAND is an operand to an expression. Perform necessary steps
6398 required before using it. If OPERAND is NULL_TREE, NULL_TREE is
6399 returned. */
6401 static tree
6403 {
6405 {
6408 /* Make sure the template type is instantiated now. */
6410 }
6413 }
6415 /* True iff CONV represents a conversion sequence which no other can be better
6416 than under [over.ics.rank]: in other words, a "conversion" to the exact same
6417 type (including binding to a reference to the same type). This is stronger
6418 than the standard's "identity" category, which also includes reference
6419 bindings that add cv-qualifiers or change rvalueness. */
6421 static bool
6423 {
6427 {
6433 }
6435 /* Brace elision is imperfect. */
6438 }
6440 /* True if CAND represents a perfect match, i.e. all perfect conversions, so no
6441 other candidate can be a better match. Since the template/non-template
6442 tiebreaker comes immediately after the conversion comparison in
6443 [over.match.best], a perfect non-template candidate is better than all
6444 templates. */
6446 static bool
6448 {
6451 /* CWG1402 makes an implicitly deleted move op worse than other
6452 candidates. */
6464 }
6466 /* True iff one of CAND's argument conversions is missing. */
6468 static bool
6470 {
6472 {
6477 {
6478 /* We don't know whether this conversion is outright invalid or
6479 just bad, so conservatively assume it's missing. */
6482 }
6483 }
6485 }
6487 /* Add each of the viable functions in FNS (a FUNCTION_DECL or
6488 OVERLOAD) to the CANDIDATES, returning an updated list of
6489 CANDIDATES. The ARGS are the arguments provided to the call;
6490 if FIRST_ARG is non-null it is the implicit object argument,
6491 otherwise the first element of ARGS is used if needed. The
6492 EXPLICIT_TARGS are explicit template arguments provided.
6493 TEMPLATE_ONLY is true if only template functions should be
6494 considered. CONVERSION_PATH, ACCESS_PATH, and FLAGS are as for
6495 add_function_candidate. */
6497 static void
6499 tree return_type,
6504 tsubst_flags_t complain)
6505 {
6506 tree ctype;
6510 unification_kind_t strict;
6516 /* Precalculate special handling of constructors and conversion ops. */
6519 {
6523 /* We're doing return_type(x). */
6525 else
6526 /* We're doing x.operator return_type(). */
6528 /* [over.match.funcs] For conversion functions, the function
6529 is considered to be a member of the class of the implicit
6530 object argument for the purpose of defining the type of
6531 the implicit object parameter. */
6533 }
6534 else
6535 {
6537 {
6539 /* For list-initialization we consider explicit constructors
6540 and complain if one is chosen. */
6541 check_converting
6544 }
6547 }
6549 /* P2468: Check if operator== is a rewrite target with first operand
6550 (*args)[0]; for now just do the lookups. */
6553 {
6556 {
6561 else
6563 }
6564 else
6565 {
6572 }
6573 }
6577 else
6578 /* Delay creating the implicit this parameter until it is needed. */
6582 /* If there's a non-template perfect match, we don't need to consider
6583 templates. So check non-templates first. This optimization is only
6584 really needed for the defaulted copy constructor of tuple and the like
6585 (96926), but it seems like we might as well enable it more generally. */
6593 /* Template candidates that we'll potentially ignore if the
6594 perfect candidate optimization succeeds. */
6597 /* During overload resolution, we first consider each function under the
6598 assumption that we'll eventually find a strictly viable candidate.
6599 This allows us to circumvent our defacto behavior when checking
6600 argument conversions and shortcut consideration of the candidate
6601 upon encountering the first bad conversion. If this assumption
6602 turns out to be false, and all candidates end up being non-strictly
6603 viable, then we reconsider such candidates under the defacto behavior.
6604 This trick is important for pruning member function overloads according
6605 to their const/ref-qualifiers (since all 'this' conversions are at
6606 worst bad) without breaking -fpermissive. */
6610 again:
6612 {
6614 {
6618 }
6620 {
6623 }
6626 {
6629 }
6635 {
6636 /* Figure out where the object arg comes from. If this
6637 function is a non-static member and we didn't get an
6638 implicit object argument, move it out of args. */
6640 {
6642 tree arg;
6649 }
6653 }
6655 /* Don't bother reversing an operator with two identical parameters. */
6657 {
6662 }
6664 /* When considering reversed operator==, if there's a corresponding
6665 operator!= in the same scope, it's not a rewrite target. */
6667 {
6673 /* ??? This kludge excludes inline namespace members for the H
6674 test in spaceship-eq15.C, but I don't see why we would want
6677 {
6680 }
6683 }
6687 fn,
6688 ctype,
6689 explicit_targs,
6690 fn_first_arg,
6691 fn_args,
6692 return_type,
6693 access_path,
6694 conversion_path,
6695 flags,
6696 strict,
6697 shortcut_bad_convs,
6698 complain);
6699 else
6700 {
6702 fn,
6703 ctype,
6704 fn_first_arg,
6705 fn_args,
6706 access_path,
6707 conversion_path,
6708 flags,
6709 NULL,
6710 shortcut_bad_convs,
6711 complain);
6714 }
6721 && shortcut_bad_convs
6723 {
6724 /* This candidate has been tentatively marked non-strictly viable,
6725 and we didn't compute all argument conversions for it (having
6726 stopped at the first bad conversion). Move it to BAD_CANDS to
6727 to fully reconsider later if we don't find any strictly viable
6728 candidates. */
6730 {
6734 }
6735 else
6736 /* But if we're in a SFINAE context, just mark this candidate as
6737 unviable outright and avoid potentially reconsidering it.
6738 This is safe to do because in a SFINAE context, performing a bad
6739 conversion is always an error (even with -fpermissive), so a
6740 non-strictly viable candidate is effectively unviable anyway. */
6742 }
6743 }
6745 {
6749 }
6751 && !seen_strictly_viable
6752 && shortcut_bad_convs
6754 {
6755 /* None of the candidates are strictly viable, so consider again those
6756 functions in BAD_CANDS, this time without shortcutting bad conversions
6757 so that all their argument conversions are computed. */
6761 {
6766 }
6770 }
6773 {
6774 /* Remember any omitted candidates; we may want to print all candidates
6775 as part of overload resolution failure diagnostics. */
6777 {
6783 }
6784 }
6785 }
6787 /* Returns 1 if P0145R2 says that the LHS of operator CODE is evaluated first,
6788 -1 if the RHS is evaluated first, or 0 if the order is unspecified. */
6790 static int
6792 {
6794 {
6795 // 5. b @= a
6799 // 6. a[b]
6803 // 1. a.b
6804 // Not overloadable (yet).
6805 // 2. a->b
6806 // Only one argument.
6807 // 3. a->*b
6809 // 7. a << b
6811 // 8. a >> b
6813 // a && b
6814 // Predates P0145R3.
6816 // a || b
6817 // Predates P0145R3.
6819 // a , b
6820 // Predates P0145R3.
6826 }
6827 }
6829 /* Subroutine of build_new_op: Add to CANDIDATES all candidates for the
6830 operator indicated by CODE/CODE2. This function calls itself recursively to
6831 handle C++20 rewritten comparison operator candidates.
6833 LOOKUPS, if non-NULL, is the set of pertinent namespace-scope operator
6834 overloads to consider. This parameter is used when instantiating a
6835 dependent operator expression and has the same structure as
6836 DEPENDENT_OPERATOR_TYPE_SAVED_LOOKUPS. */
6838 static tree
6843 {
6848 /* LOOKUP_REWRITTEN is set when we're looking for the == or <=> operator to
6849 rewrite from, and also when we're looking for the e.g. < operator to use
6850 on the result of <=>. In the latter case, we don't want the flag set in
6851 the candidate, we just want to suppress looking for rewrites. */
6858 {
6859 /* =, ->, [], () must be non-static member functions. */
6863 /* FALLTHRU */
6871 }
6873 /* Add namespace-scope operators to the list of functions to
6874 consider. */
6876 {
6877 tree fns;
6880 /* If LOOKUPS is non-NULL, then we're instantiating a dependent operator
6881 expression, and LOOKUPS is the result of stage 1 name lookup. */
6884 else
6890 }
6892 /* Add class-member operators to the candidate set. */
6897 {
6902 {
6904 {
6915 /* Release the vec if we didn't add a candidate that uses it. */
6918 {
6921 }
6923 }
6924 else
6931 }
6932 }
6933 /* Per [over.match.oper]3.2, if no operand has a class type, then
6934 only non-member functions that have type T1 or reference to
6935 cv-qualified-opt T1 for the first argument, if the first argument
6936 has an enumeration type, or T2 or reference to cv-qualified-opt
6937 T2 for the second argument, if the second argument has an
6938 enumeration type. Filter out those that don't match. */
6940 {
6944 {
6952 {
6959 && (same_type_ignoring_top_level_qualifiers_p
6964 }
6966 /* No argument has an appropriate type, so remove this
6967 candidate function from the list. */
6969 {
6972 }
6973 }
6974 }
6977 {
6978 /* The standard says to rewrite built-in candidates, too,
6979 but there's no point. */
6983 /* Maybe add C++20 rewritten comparison candidates. */
6989 {
7004 }
7007 {
7010 /* Add rewritten candidates in same order. */
7016 /* Add rewritten candidates in reverse order. */
7024 /* Release the vec if we didn't add a candidate that uses it. */
7027 {
7030 }
7032 }
7033 }
7036 }
7038 tree
7042 {
7044 releasing_vec arglist;
7060 conversion_obstack_sentinel cos;
7064 {
7067 }
7075 {
7080 /* Use build_operator_new_call and build_op_delete_call instead. */
7084 /* Use build_op_call instead. */
7091 /* These are saved for the sake of warn_logical_operator. */
7101 /* These are saved for the sake of maybe_warn_bool_compare. */
7108 }
7114 /* Use build_conditional_expr instead. */
7121 {
7124 }
7138 {
7141 /* For these, the built-in candidates set is empty
7142 [over.match.oper]/3. We don't want non-strict matches
7143 because exact matches are always possible with built-in
7144 operators. The built-in candidate set for COMPONENT_REF
7145 would be empty too, but since there are no such built-in
7146 operators, we accept non-strict matches for them. */
7153 }
7157 {
7159 {
7162 /* Don't try anything fancy if we're not allowed to produce
7163 errors. */
7167 /* Look for an `operator++ (int)'. Pre-1985 C++ didn't
7168 distinguish between prefix and postfix ++ and
7169 operator++() was used for both, so we allow this with
7170 -fpermissive. */
7171 else
7172 {
7179 }
7186 else
7192 /* The caller will deal with these. */
7203 {
7204 /* If one of the arguments of the operator represents
7205 an invalid use of member function pointer, try to report
7206 a meaningful error ... */
7211 else
7212 {
7213 /* ... Otherwise, report the more generic
7214 "no matching operator found" error */
7215 auto_diagnostic_group d;
7218 }
7219 }
7222 }
7223 }
7224 else
7225 {
7228 {
7230 {
7231 auto_diagnostic_group d;
7234 }
7238 }
7240 {
7246 else
7247 {
7250 /* We'll wrap this call in another one. */
7253 {
7254 /* We swapped these in add_candidate, swap them back now. */
7258 "current function recursively with reversed "
7260 }
7262 }
7267 {
7271 /* Specify evaluation order as per P0145R2. */
7274 {
7285 }
7286 }
7288 /* If this was a C++20 rewritten comparison, adjust the result. */
7290 {
7291 /* FIXME build_min_non_dep_op_overload can't handle rewrites. */
7295 {
7301 ;
7302 /* If a rewritten operator== candidate is selected by
7303 overload resolution for an operator @, its return type
7304 shall be cv bool.... */
7306 {
7308 {
7309 auto_diagnostic_group d;
7315 }
7317 }
7319 /* !(y == x) or !(x == y) */
7324 /* If a rewritten operator<=> candidate is selected by
7325 overload resolution for an operator @, x @ y is
7326 interpreted as 0 @ (y <=> x) if the selected candidate is
7327 a synthesized candidate with reversed order of parameters,
7328 or (x <=> y) @ 0 otherwise, using the selected rewritten
7329 operator<=> candidate. */
7332 /* We're in the build_new_op call below for an outer
7333 reversed call; we don't need to do anything more. */
7340 {
7350 }
7355 }
7356 }
7358 /* In an expression of the form `a[]' where cand->fn
7359 which is operator[] turns out to be a static member function,
7360 `a' is none-the-less evaluated. */
7363 }
7364 else
7365 {
7366 /* Give any warnings we noticed during overload resolution. */
7368 {
7372 }
7374 /* Check for comparison of different enum types. */
7376 {
7387 {
7397 }
7401 }
7403 /* "If a built-in candidate is selected by overload resolution, the
7404 operands of class type are converted to the types of the
7405 corresponding parameters of the selected operation function,
7406 except that the second standard conversion sequence of a
7407 user-defined conversion sequence (12.3.3.1.2) is not applied." */
7410 {
7413 }
7416 {
7419 {
7422 }
7423 }
7426 {
7429 {
7432 }
7433 }
7434 }
7435 }
7440 builtin:
7442 {
7457 /* Fall through. */
7470 /* Fall through. */
7505 RO_ARROW_STAR,
7506 complain),
7509 /* The caller will deal with these. */
7517 }
7519 }
7521 /* Build a new call to operator[]. This may change ARGS. */
7523 tree
7526 tsubst_flags_t complain)
7527 {
7545 {
7550 }
7551 else
7555 {
7559 }
7561 conversion_obstack_sentinel cos;
7564 {
7572 }
7574 /* Be strict here because if we choose a bad conversion candidate, the
7575 errors we get won't mention the call context. */
7578 {
7580 {
7581 auto_diagnostic_group d;
7585 }
7587 }
7588 else
7589 {
7592 {
7594 {
7595 auto_diagnostic_group d;
7599 }
7601 }
7605 {
7612 {
7616 /* Specify evaluation order as per P0145R2. */
7618 }
7620 /* In an expression of the form `a[]' where cand->fn
7621 which is operator[] turns out to be a static member function,
7622 `a' is none-the-less evaluated. */
7624 }
7625 else
7627 }
7630 }
7632 /* CALL was returned by some call-building function; extract the actual
7633 CALL_EXPR from any bits that have been tacked on, e.g. by
7634 convert_from_reference. */
7636 tree
7638 {
7647 {
7648 /* C++20 rewritten comparison operators. */
7657 {
7661 else
7663 }
7666 }
7673 }
7675 /* Returns true if FN has two parameters, of which the second has type
7676 size_t. */
7678 static bool
7680 {
7688 }
7690 /* True if T, an allocation function, has std::align_val_t as its second
7691 argument. */
7693 bool
7695 {
7701 }
7703 /* True if T is std::destroying_delete_t. */
7705 static bool
7707 {
7710 }
7712 /* A deallocation function with at least two parameters whose second parameter
7713 type is of type std::destroying_delete_t is a destroying operator delete. A
7714 destroying operator delete shall be a class member function named operator
7715 delete. [ Note: Array deletion cannot use a destroying operator
7716 delete. --end note ] */
7718 tree
7720 {
7726 }
7728 struct dealloc_info
7729 {
7732 tree destroying;
7733 };
7735 /* Returns true iff T, an element of an OVERLOAD chain, is a usual deallocation
7736 function (3.7.4.2 [basic.stc.dynamic.deallocation]). If so, and DI is
7737 non-null, also set *DI. */
7739 static bool
7741 {
7744 /* A template instance is never a usual deallocation function,
7745 regardless of its signature. */
7750 /* A usual deallocation function is a deallocation function whose parameters
7751 after the first are
7752 - optionally, a parameter of type std::destroying_delete_t, then
7753 - optionally, a parameter of type std::size_t, then
7754 - optionally, a parameter of type std::align_val_t. */
7758 {
7761 }
7765 {
7768 }
7771 {
7774 }
7776 }
7778 /* Just return whether FN is a usual deallocation function. */
7780 bool
7782 {
7784 }
7786 /* Build a call to operator delete. This has to be handled very specially,
7787 because the restrictions on what signatures match are different from all
7788 other call instances. For a normal delete, only a delete taking (void *)
7789 or (void *, size_t) is accepted. For a placement delete, only an exact
7790 match with the placement new is accepted.
7792 CODE is either DELETE_EXPR or VEC_DELETE_EXPR.
7793 ADDR is the pointer to be deleted.
7794 SIZE is the size of the memory block to be deleted.
7795 GLOBAL_P is true if the delete-expression should not consider
7796 class-specific delete operators.
7797 PLACEMENT is the corresponding placement new call, or NULL_TREE.
7799 If this call to "operator delete" is being generated as part to
7800 deallocate memory allocated via a new-expression (as per [expr.new]
7801 which requires that if the initialization throws an exception then
7802 we call a deallocation function), then ALLOC_FN is the allocation
7803 function. */
7805 tree
7809 {
7812 dealloc_info di_fn = { };
7824 /* In [class.free]
7826 If the result of the lookup is ambiguous or inaccessible, or if
7827 the lookup selects a placement deallocation function, the
7828 program is ill-formed.
7830 Therefore, we ask lookup_fnfields to complain about ambiguity. */
7831 {
7835 }
7836 else
7842 /* Strip const and volatile from addr. */
7849 {
7850 /* "A declaration of a placement deallocation function matches the
7851 declaration of a placement allocation function if it has the same
7852 number of parameters and, after parameter transformations (8.3.5),
7853 all parameter types except the first are identical."
7855 So we build up the function type we want and ask instantiate_type
7856 to get it for us. */
7867 /* "If the lookup finds the two-parameter form of a usual deallocation
7868 function (3.7.4.2) and that function, considered as a placement
7869 deallocation function, would have been selected as a match for the
7870 allocation function, the program is ill-formed." */
7872 {
7880 /* But if the class has an operator delete (void *), then that is
7881 the usual deallocation function, so we shouldn't complain
7882 about using the operator delete (void *, size_t). */
7885 {
7889 }
7890 /* Before C++14 a two-parameter global deallocation function is
7891 always a placement deallocation function, but warn if
7892 -Wc++14-compat. */
7894 {
7896 {
7897 auto_diagnostic_group d;
7900 }
7902 }
7905 {
7906 auto_diagnostic_group d;
7908 {
7909 /* Only mention C++14 for namespace-scope delete. */
7912 else
7914 "%qD is a usual (non-placement) deallocation "
7916 }
7917 }
7918 else
7920 ok:;
7921 }
7922 }
7923 else
7924 /* "Any non-placement deallocation function matches a non-placement
7925 allocation function. If the lookup finds a single matching
7926 deallocation function, that function will be called; otherwise, no
7927 deallocation function will be called." */
7929 {
7930 dealloc_info di_elt;
7932 {
7933 /* If we're called for an EH cleanup in a new-expression, we can't
7934 use a destroying delete; the exception was thrown before the
7935 object was constructed. */
7937 {
7940 }
7943 {
7947 }
7949 /* -- If any of the deallocation functions is a destroying
7950 operator delete, all deallocation functions that are not
7951 destroying operator deletes are eliminated from further
7952 consideration. */
7954 {
7956 {
7959 }
7961 }
7963 /* -- If the type has new-extended alignment, a function with a
7964 parameter of type std::align_val_t is preferred; otherwise a
7965 function without such a parameter is preferred. If exactly one
7966 preferred function is found, that function is selected and the
7967 selection process terminates. If more than one preferred
7968 function is found, all non-preferred functions are eliminated
7969 from further consideration. */
7971 {
7974 {
7976 {
7979 }
7981 }
7982 }
7984 /* -- If the deallocation functions have class scope, the one
7985 without a parameter of type std::size_t is selected. */
7990 /* -- If the type is complete and if, for the second alternative
7991 (delete array) only, the operand is a pointer to a class type
7992 with a non-trivial destructor or a (possibly multi-dimensional)
7993 array thereof, the function with a parameter of type std::size_t
7994 is selected.
7996 -- Otherwise, it is unspecified whether a deallocation function
7997 with a parameter of type std::size_t is selected. */
7998 else
7999 {
8003 /* We need a cookie to determine the array size. */
8005 }
8008 {
8011 }
8012 }
8013 }
8015 /* If we have a matching function, call it. */
8017 {
8020 /* If the FN is a member function, make sure that it is
8021 accessible. */
8024 complain);
8026 /* Core issue 901: It's ok to new a type with deleted delete. */
8030 tree ret;
8032 {
8033 /* The placement args might not be suitable for overload
8034 resolution at this point, so build the call directly. */
8044 }
8045 else
8046 {
8049 {
8050 /* Strip const and volatile from addr but retain the type of the
8051 object. */
8058 complain);
8059 }
8061 releasing_vec args;
8068 {
8071 }
8073 }
8075 /* Set this flag for all callers of this function. In addition to
8076 delete-expressions, this is called for deallocating coroutine state;
8077 treat that as an implicit delete-expression. This is also called for
8078 the delete if the constructor throws in a new-expression, and for a
8079 deleting destructor (which implements a delete-expression). */
8080 /* But leave this flag off for destroying delete to avoid wrong
8081 assumptions in the optimizers. */
8087 }
8089 /* If there's only a destroying delete that we can't use because the
8090 object isn't constructed yet, and we used global new, use global
8091 delete as well. */
8097 /* [expr.new]
8099 If no unambiguous matching deallocation function can be found,
8100 propagating the exception does not cause the object's memory to
8101 be freed. */
8103 {
8106 {
8109 alloc_fn);
8112 "delete %qD cannot be used to release the allocated memory"
8113 " if the initialization throws because the object is not "
8115 }
8117 }
8123 }
8125 /* Issue diagnostics about a disallowed access of DECL, using DIAG_DECL
8126 in the diagnostics.
8128 If ISSUE_ERROR is true, then issue an error about the access, followed
8129 by a note showing the declaration. Otherwise, just show the note.
8131 DIAG_DECL and DIAG_LOCATION will almost always be the same.
8132 DIAG_LOCATION is just another DECL. NO_ACCESS_REASON is an optional
8133 parameter used to specify why DECL wasn't accessible (e.g. ak_private
8134 would be because DECL was private). If not using NO_ACCESS_REASON,
8135 then it must be ak_none, and the access failure reason will be
8136 figured out by looking at the protection of DECL. */
8138 void
8141 {
8142 /* If we have not already figured out why DECL is inaccessible... */
8144 {
8145 /* Examine the access of DECL to find out why. */
8150 }
8152 /* Now generate an error message depending on calculated access. */
8154 {
8158 }
8160 {
8164 }
8165 /* Couldn't figure out why DECL is inaccesible, so just say it's
8166 inaccessible. */
8167 else
8168 {
8172 }
8173 }
8175 /* Initialize a temporary of type TYPE with EXPR. The FLAGS are a
8176 bitwise or of LOOKUP_* values. If any errors are warnings are
8177 generated, set *DIAGNOSTIC_FN to "error" or "warning",
8178 respectively. If no diagnostics are generated, set *DIAGNOSTIC_FN
8179 to NULL. */
8181 static tree
8184 {
8189 /* If the source is a packed field, calling the copy constructor will require
8190 binding the field to the reference parameter to the copy constructor, and
8191 we'll end up with an infinite loop. If we can use a bitwise copy, then
8192 do that now. */
8198 /* In decltype, we might have decided not to wrap this call in a TARGET_EXPR.
8199 But it turns out to be a subexpression, so perform temporary
8200 materialization now. */
8215 }
8217 /* Get any location for EXPR, falling back to input_location.
8219 If the result is in a system header and is the virtual location for
8220 a token coming from the expansion of a macro, unwind it to the
8221 location of the expansion point of the macro (e.g. to avoid the
8222 diagnostic being suppressed for expansions of NULL where "NULL" is
8223 in a system header). */
8225 static location_t
8227 {
8231 }
8233 /* Perform warnings about peculiar, but valid, conversions from/to NULL.
8234 Also handle a subset of zero as null warnings.
8235 EXPR is implicitly converted to type TOTYPE.
8236 FN and ARGNUM are used for diagnostics. */
8238 static void
8240 {
8241 /* Issue warnings about peculiar, but valid, uses of NULL. */
8245 {
8248 {
8249 auto_diagnostic_group d;
8255 }
8256 else
8259 }
8261 /* Issue warnings if "false" is converted to a NULL pointer */
8264 {
8267 {
8268 auto_diagnostic_group d;
8270 "converting %<false%> to pointer type for argument "
8274 }
8275 else
8278 }
8279 /* Handle zero as null pointer warnings for cases other
8280 than EQ_EXPR and NE_EXPR */
8283 {
8286 }
8287 }
8289 /* We gave a diagnostic during a conversion. If this was in the second
8290 standard conversion sequence of a user-defined conversion sequence, say
8291 which user-defined conversion. */
8293 static void
8295 {
8299 {
8303 }
8304 }
8306 /* Locate the parameter with the given index within FNDECL.
8307 ARGNUM is zero based, -1 indicates the `this' argument of a method.
8308 Return the location of the FNDECL itself if there are problems. */
8310 location_t
8312 {
8313 /* The locations of implicitly-declared functions are likely to be
8314 more meaningful than those of their parameters. */
8319 tree param;
8321 /* Locate param by index within DECL_ARGUMENTS (fndecl). */
8325 ;
8327 /* If something went wrong (e.g. if we have a builtin and thus no arguments),
8328 return the location of FNDECL. */
8333 }
8335 /* If FNDECL is non-NULL, issue a note highlighting ARGNUM
8336 within its declaration (or the fndecl itself if something went
8337 wrong). */
8339 void
8341 {
8345 }
8347 /* Maybe warn about C++20 Conversions to arrays of unknown bound. C is
8348 the conversion, EXPR is the expression we're converting. */
8350 static void
8352 {
8365 "conversions to arrays of unknown bound "
8367 }
8369 /* We call this recursively in convert_like_internal. */
8371 tsubst_flags_t);
8373 /* Perform the conversions in CONVS on the expression EXPR. FN and
8374 ARGNUM are used for diagnostics. ARGNUM is zero based, -1
8375 indicates the `this' argument of a method. INNER is nonzero when
8376 being called to continue a conversion chain. It is negative when a
8377 reference binding will be applied, positive otherwise. If
8378 ISSUE_CONVERSION_WARNINGS is true, warnings about suspicious
8379 conversions will be emitted if appropriate. If C_CAST_P is true,
8380 this conversion is coming from a C-style cast; in that case,
8381 conversions to inaccessible bases are permitted. */
8383 static tree
8387 {
8389 diagnostic_t diag_kind;
8405 {
8409 /* Give a helpful error if this is bad because of excess braces. */
8414 {
8420 }
8422 /* Give a helpful error if this is bad because a conversion to bool
8423 from std::nullptr_t requires direct-initialization. */
8435 totype))
8436 {
8439 "converting to %qH from %qI with greater "
8447 "converting to %qH from %qI with unordered "
8455 }
8458 {
8460 {
8461 auto_diagnostic_group d;
8464 totype);
8470 complain);
8471 }
8473 {
8477 complain);
8481 }
8486 complain);
8489 }
8491 {
8497 }
8501 complain);
8502 else
8507 }
8513 {
8515 {
8519 /* We chose the surrogate function from add_conv_candidate, now we
8520 actually need to build the conversion. */
8526 /* When converting from an init list we consider explicit
8527 constructors, but actually trying to call one is an error. */
8530 /* Unless this is for direct-list-initialization. */
8532 /* And in C++98 a default constructor can't be explicit. */
8534 {
8540 {
8541 auto_diagnostic_group d;
8545 {
8547 convfn);
8550 }
8551 }
8552 else
8553 {
8554 auto_diagnostic_group d;
8558 convfn);
8559 }
8560 }
8562 /* If we're initializing from {}, it's value-initialization. */
8567 {
8574 {
8577 }
8579 }
8581 /* We don't know here whether EXPR is being used as an lvalue or
8582 rvalue, but we know it's read. */
8585 /* Pass LOOKUP_NO_CONVERSION so rvalue/base handling knows not to allow
8586 any more UDCs. */
8588 complain);
8590 /* If this is a constructor or a function returning an aggr type,
8591 we need to build up a TARGET_EXPR. */
8593 {
8596 /* Remember that this was list-initialization. */
8599 }
8602 }
8605 {
8611 else
8613 }
8624 /* If __null has been converted to an integer type, we do not want to
8625 continue to warn about uses of EXPR as an integer, rather than as a
8626 pointer. */
8630 /* We leave bad_p off ck_ambig because overload resolution considers
8631 it valid, it just fails when we try to perform it. So we need to
8632 check complain here, too. */
8634 {
8635 /* Call build_user_type_conversion again for the error. */
8641 }
8645 {
8646 /* Conversion to std::initializer_list<T>. */
8649 tree array;
8652 {
8653 elttype = cp_build_qualified_type
8659 }
8661 {
8666 /* Convert all the elements. */
8668 {
8681 }
8682 /* Build up the array. */
8683 elttype = cp_build_qualified_type
8687 /* This is dubious now, should be blessed by P2752. */
8690 }
8691 else
8698 /* Build up the initializer_list object. Note: fail gracefully
8699 if the object cannot be completed because, for example, no
8700 definition is provided (c++/80956). */
8711 }
8715 {
8724 }
8727 complain);
8734 };
8744 {
8748 {
8750 {
8751 auto_diagnostic_group d;
8754 }
8756 }
8761 /* Don't introduce copies when passing arguments along to the inherited
8762 constructor. */
8764 && flag_new_inheriting_ctors
8770 /* Copy-list-initialization doesn't actually involve a copy. */
8773 /* Fall through. */
8776 {
8777 /* We are going to bind a reference directly to a base-class
8778 subobject of EXPR. */
8779 /* Build an expression for `*((base*) &expr)'. */
8783 }
8785 /* Copy-initialization where the cv-unqualified version of the source
8786 type is the same class as, or a derived class of, the class of the
8787 destination [is treated as direct-initialization]. [dcl.init] */
8789 /* This conversion is being done in the context of a user-defined
8790 conversion (i.e. the second step of copy-initialization), so
8791 don't allow any more. */
8794 /* We might be performing a conversion of the argument
8795 to the user-defined conversion, i.e., not a conversion of the
8796 result of the user-defined conversion. In which case we skip
8797 explicit constructors. */
8802 {
8803 auto_diagnostic_group d;
8806 }
8811 {
8814 /* direct_reference_binding might have inserted a ck_qual under
8815 this ck_ref_bind for the benefit of conversion sequence ranking.
8816 Ignore the conversion; we'll create our own below. */
8819 {
8822 /* Strip the cast created by the ck_qual; cp_build_addr_expr
8823 below expects an lvalue. */
8825 }
8828 {
8830 auto_diagnostic_group d;
8837 {
8840 {
8845 }
8852 extype);
8853 }
8855 {
8856 /* If we're converting from T[] to T[N], don't talk
8857 about discarding qualifiers. (Converting from T[N] to
8858 T[] is allowed by P0388R4.) */
8865 else
8868 }
8869 else
8875 }
8879 /* If necessary, create a temporary.
8881 VA_ARG_EXPR and CONSTRUCTOR expressions are special cases
8882 that need temporaries, even when their types are reference
8883 compatible with the type of reference being bound, so the
8884 upcoming call to cp_build_addr_expr doesn't fail. */
8888 {
8889 /* Otherwise, a temporary of type "cv1 T1" is created and
8890 initialized from the initializer expression using the rules
8891 for a non-reference copy-initialization (8.5). */
8899 {
8900 /* If the reference is volatile or non-const, we
8901 cannot create a temporary. */
8903 {
8910 else
8913 }
8915 }
8916 /* If the source is a packed field, and we must use a copy
8917 constructor, then building the target expr will require
8918 binding the field to the reference parameter to the
8919 copy constructor, and we'll end up with an infinite
8920 loop. If we can use a bitwise copy, then we'll be
8921 OK. */
8925 {
8929 }
8931 {
8934 }
8936 /* Creating &TARGET_EXPR<> in a template would break when
8937 tsubsting the expression, so use an IMPLICIT_CONV_EXPR
8938 instead. This can happen even when there's no class
8939 involved, e.g., when converting an integer to a reference
8940 type. */
8944 }
8946 /* Take the address of the thing to which we will bind the
8947 reference. */
8952 /* Convert it to a pointer to the type referred to by the
8953 reference. This will adjust the pointer if a derived to
8954 base conversion is being performed. */
8957 /* Convert the pointer to the desired reference type. */
8959 }
8965 /* ??? Should the address of a transaction-safe pointer point to the TM
8966 clone, and this conversion look up the primary function? */
8970 /* Warn about deprecated conversion if appropriate. */
8972 {
8975 }
8990 }
9000 else
9001 {
9005 }
9008 }
9010 /* Return true if converting FROM to TO is unsafe in a template. */
9012 static bool
9014 {
9015 /* Converting classes involves TARGET_EXPR. */
9019 /* Converting real to integer produces FIX_TRUNC_EXPR which tsubst
9020 doesn't handle. */
9024 /* Converting integer to real isn't a trivial conversion, either. */
9029 }
9031 /* Wrapper for convert_like_internal that handles creating
9032 IMPLICIT_CONV_EXPR. */
9034 static tree
9037 tsubst_flags_t complain)
9038 {
9039 /* Creating &TARGET_EXPR<> in a template breaks when substituting,
9040 and creating a CALL_EXPR in a template breaks in finish_call_expr
9041 so use an IMPLICIT_CONV_EXPR for this conversion. We would have
9042 created such codes e.g. when calling a user-defined conversion
9043 function. */
9048 {
9054 /* Do the normal processing to give the bad_p errors. But we still
9055 need to return the IMPLICIT_CONV_EXPR, unless we're returning
9056 error_mark_node. */
9057 }
9064 }
9066 /* Convenience wrapper for convert_like. */
9070 {
9074 }
9076 /* Convenience wrapper for convert_like. */
9080 tsubst_flags_t complain)
9081 {
9085 }
9087 /* ARG is being passed to a varargs function. Perform any conversions
9088 required. Return the converted value. */
9090 tree
9092 {
9096 /* [expr.call]
9098 If the argument has integral or enumeration type that is subject
9099 to the integral promotions (_conv.prom_), or a floating-point
9100 type that is subject to the floating-point promotion
9101 (_conv.fpprom_), the value of the argument is converted to the
9102 promoted type before the call. */
9108 {
9112 "implicit conversion from %qH to %qI when passing "
9119 }
9121 {
9124 {
9127 }
9128 else
9130 }
9132 {
9134 {
9136 complain);
9143 arg_type,
9147 }
9148 else
9150 }
9151 else
9152 /* [expr.call]
9154 The lvalue-to-rvalue, array-to-pointer, and function-to-pointer
9155 standard conversions are performed. */
9162 /* In a template (or ill-formed code), we can have an incomplete type
9163 even after require_complete_type, in which case we don't know
9164 whether it has trivial copy or not. */
9167 {
9168 /* [expr.call] 5.2.2/7:
9169 Passing a potentially-evaluated argument of class type (Clause 9)
9170 with a non-trivial copy constructor or a non-trivial destructor
9171 with no corresponding parameter is conditionally-supported, with
9172 implementation-defined semantics.
9174 We support it as pass-by-invisible-reference, just like a normal
9175 value parameter.
9177 If the call appears in the context of a sizeof expression,
9178 it is not potentially-evaluated. */
9181 {
9185 "passing objects of non-trivially-copyable "
9187 arg_type);
9189 }
9190 /* Build up a real lvalue-to-rvalue conversion in case the
9191 copy constructor is trivial but not callable. */
9195 }
9198 }
9200 /* va_arg (EXPR, TYPE) is a builtin. Make sure it is not abused. */
9202 tree
9204 {
9206 {
9210 }
9220 {
9223 }
9227 {
9228 /* conditionally-supported behavior [expr.call] 5.2.2/7. Let's treat
9229 it as pass by invisible reference. */
9231 "receiving objects of non-trivially-copyable type %q#T "
9237 }
9241 /* Wrap the VA_ARG_EXPR in a TARGET_EXPR now so other code doesn't need to
9242 know how to handle it. */
9245 }
9247 /* TYPE has been given to va_arg. Apply the default conversions which
9248 would have happened when passed via ellipsis. Return the promoted
9249 type, or the passed type if there is no change. */
9251 tree
9253 {
9254 tree promote;
9256 /* Perform the array-to-pointer and function-to-pointer
9257 conversions. */
9265 }
9267 /* ARG is a default argument expression being passed to a parameter of
9268 the indicated TYPE, which is a parameter to FN. PARMNUM is the
9269 zero-based argument number. Do any required conversions. Return
9270 the converted value. */
9273 void
9277 void
9281 tree
9283 tsubst_flags_t complain)
9284 {
9286 tree t;
9288 /* See through clones. */
9290 /* And inheriting ctors. */
9294 /* Detect recursion. */
9297 {
9301 }
9303 /* If the ARG is an unparsed default argument expression, the
9304 conversion cannot be performed. */
9306 {
9311 }
9318 /* Due to:
9320 [dcl.fct.default]
9322 The names in the expression are bound, and the semantic
9323 constraints are checked, at the point where the default
9324 expressions appears.
9326 we must not perform access checks here. */
9328 /* We must make a copy of ARG, in case subsequent processing
9329 alters any part of it. */
9334 complain);
9341 }
9343 /* Returns the type which will really be used for passing an argument of
9344 type TYPE. */
9346 tree
9348 {
9349 /* Pass classes with copy ctors by invisible reference. */
9359 }
9361 /* Actually perform the appropriate conversion. */
9363 tree
9365 {
9366 tree bitfield_type;
9368 /* If VAL is a bitfield, then -- since it has already been converted
9369 to TYPE -- it cannot have a precision greater than TYPE.
9371 If it has a smaller precision, we must widen it here. For
9372 example, passing "int f:3;" to a function expecting an "int" will
9373 not result in any conversion before this point.
9375 If the precision is the same we must not risk widening. For
9376 example, the COMPONENT_REF for a 32-bit "long long" bitfield will
9377 often have type "int", even though the C++ type for the field is
9378 "long long". If the value is being passed to a function
9379 expecting an "int", then no conversions will be required. But,
9380 if we call convert_bitfield_to_declared_type, the bitfield will
9381 be converted to "long long". */
9388 ;
9389 /* Pass classes with copy ctors by invisible reference. */
9398 {
9400 {
9408 "argument of function call might be a candidate "
9410 }
9412 }
9418 }
9420 /* Returns non-zero iff FN is a function with magic varargs, i.e. ones for
9421 which just decay_conversion or no conversions at all should be done.
9422 This is true for some builtins which don't act like normal functions.
9423 Return 2 if just decay_conversion and removal of excess precision should
9424 be done, 1 if just decay_conversion. Return 3 for special treatment of
9425 the 3rd argument for __builtin_*_overflow_p. Return 4 for special
9426 treatment of the 1st argument for
9427 __builtin_{clz,ctz,clrsb,ffs,parity,popcount}g. */
9429 int
9431 {
9434 {
9465 }
9468 }
9470 /* Returns the decl of the dispatcher function if FN is a function version. */
9472 tree
9474 {
9487 {
9491 }
9496 }
9498 /* fn is a function version dispatcher that is marked used. Mark all the
9499 semantically identical function versions it will dispatch as used. */
9501 void
9503 {
9520 /* All semantically identical versions are chained. Traverse and mark each
9521 one of them as used. */
9524 {
9527 }
9528 }
9530 /* Build a call to "the copy constructor" for the type of A, even if it
9531 wouldn't be selected by normal overload resolution. Used for
9532 diagnostics. */
9534 static tree
9536 {
9546 }
9548 /* Return the base constructor corresponding to COMPLETE_CTOR or NULL_TREE. */
9550 static tree
9552 {
9553 tree clone;
9558 }
9560 /* Try to make EXP suitable to be used as the initializer for a base subobject,
9561 and return whether we were successful. EXP must have already been cleared
9562 by unsafe_copy_elision_p{,_opt}. */
9564 static bool
9566 {
9572 {
9575 {
9577 /* If unsafe_copy_elision_p was false, the arms should match. */
9579 }
9581 }
9583 /* A trivial copy is OK. */
9586 /* unsafe_copy_elision_p_opt must have said this is OK. */
9594 /* The base constructor has more parameters, so we can't just change the
9595 call target. It would be possible to splice in the appropriate
9596 arguments, but probably not worth the complexity. */
9601 }
9603 /* Return 2 if T refers to a base, 1 if a potentially-overlapping field,
9604 neither of which can be used for return by invisible reference. We avoid
9605 doing C++17 mandatory copy elision for either of these cases.
9607 This returns non-zero even if the type of T has no tail padding that other
9608 data could be allocated into, because that depends on the particular ABI.
9609 unsafe_copy_elision_p_opt does consider whether there is padding. */
9611 int
9613 {
9614 /* Check empty bases separately, they don't have fields. */
9618 /* A delegating constructor might be used to initialize a base. */
9633 /* The middle-end will do the right thing for scalar types. */
9640 }
9642 /* True IFF EXP is a prvalue that represents return by invisible reference. */
9644 static bool
9646 {
9647 /* Copy elision only happens with a TARGET_EXPR. */
9651 /* build_compound_expr pushes COMPOUND_EXPR inside TARGET_EXPR. */
9655 {
9656 /* We'll end up copying from each of the arms of the COND_EXPR directly
9657 into the target, so look at them. */
9662 }
9665 }
9667 /* We can't elide a copy from a function returning by value to a
9668 potentially-overlapping subobject, as the callee might clobber tail padding.
9669 Return true iff this could be that case.
9671 Places that use this function (or _opt) to decide to elide a copy should
9672 probably use make_safe_copy_elision instead. */
9674 bool
9676 {
9678 }
9680 /* As above, but for optimization allow more cases that are actually safe. */
9682 static bool
9684 {
9686 /* It's safe to elide the copy for a class with no tail padding. */
9691 }
9693 /* Try to make EXP suitable to be used as the initializer for TARGET,
9694 and return whether we were successful. */
9696 bool
9698 {
9707 }
9709 /* True IFF the result of the conversion C is a prvalue. */
9711 static bool
9713 {
9725 }
9727 /* True iff C is a conversion that binds a reference to a prvalue. */
9729 static bool
9731 {
9738 }
9740 /* True iff EXPR represents a (subobject of a) temporary. */
9742 static bool
9744 {
9748 }
9750 /* True iff C is a conversion that binds a reference to a temporary.
9751 This is a superset of conv_binds_ref_to_prvalue: here we're also
9752 interested in xvalues. */
9754 static bool
9756 {
9762 /* This is the case for
9763 struct Base {};
9764 struct Derived : Base {};
9765 const Base& b(Derived{});
9766 where we bind 'b' to the Base subobject of a temporary object of type
9767 Derived. The subobject is an xvalue; the whole object is a prvalue.
9769 The ck_base doesn't have to be present for cases like X{}.m. */
9776 }
9778 /* Return tristate::TS_TRUE if converting EXPR to a reference type TYPE binds
9779 the reference to a temporary. Return tristate::TS_FALSE if converting
9780 EXPR to a reference type TYPE doesn't bind the reference to a temporary. If
9781 the conversion is invalid or bad, return tristate::TS_UNKNOWN. DIRECT_INIT_P
9782 says whether the conversion should be done in direct- or copy-initialization
9783 context. */
9785 tristate
9787 {
9790 conversion_obstack_sentinel cos;
9800 }
9802 /* Call the trivial destructor for INSTANCE, which can be either an lvalue of
9803 class type or a pointer to class type. If NO_PTR_DEREF is true and
9804 INSTANCE has pointer type, clobber the pointer rather than what it points
9805 to. */
9807 tree
9809 {
9813 {
9814 no_clobber:
9816 }
9820 {
9824 }
9826 /* A trivial destructor should still clobber the object. */
9830 }
9832 /* Return true if in an immediate function context, or an unevaluated operand,
9833 or a default argument/member initializer, or a subexpression of an immediate
9834 invocation. */
9836 bool
9838 {
9842 /* DR 2631: default args and DMI aren't immediately evaluated.
9843 Return true here so immediate_invocation_p returns false. */
9848 }
9850 /* Return true if a call to FN with number of arguments NARGS
9851 is an immediate invocation. */
9853 bool
9855 {
9859 }
9861 /* Subroutine of the various build_*_call functions. Overload resolution
9862 has chosen a winning candidate CAND; build up a CALL_EXPR accordingly.
9863 ARGS is a TREE_LIST of the unconverted arguments to the call. FLAGS is a
9864 bitmask of various LOOKUP_* flags which apply to the call itself. */
9866 static tree
9868 {
9875 tree val;
9880 /* In a template, there is no need to perform all of the work that
9881 is normally done. We are only interested in the type of the call
9882 expression, i.e., the return type of the function. Any semantic
9883 errors will be deferred until the template is instantiated. */
9885 {
9888 else
9889 /* Otherwise set TREE_USED for the benefit of -Wunused-function.
9890 See PR80598. */
9894 tree callee;
9896 {
9900 }
9901 else
9902 {
9907 }
9914 {
9921 {
9924 }
9925 /* Look through *(const T *)&obj. */
9927 {
9931 {
9936 }
9937 }
9940 obj_arg);
9941 }
9943 }
9945 /* Give any warnings we noticed during overload resolution. */
9947 {
9951 }
9953 /* Core issue 2327: P0135 doesn't say how to handle the case where the
9954 argument to the copy constructor ends up being a prvalue after
9955 conversion. Let's do the normal processing, but pretend we aren't
9956 actually using the copy constructor. */
9965 {
9968 }
9970 /* OK, we're actually calling this inherited constructor; set its deletedness
9971 appropriately. We can get away with doing this here because calling is
9972 the only way to refer to a constructor. */
9975 {
9979 }
9981 /* Make =delete work with SFINAE. */
9983 {
9985 {
9988 {
9991 else
9993 "use %<-fdiagnostics-all-candidates%> to display "
9995 }
9996 }
9998 }
10001 {
10002 tree access_fn;
10003 /* If FN is a template function, two cases must be considered.
10004 For example:
10006 struct A {
10007 protected:
10008 template <class T> void f();
10009 };
10010 template <class T> struct B {
10011 protected:
10012 void g();
10013 };
10014 struct C : A, B<int> {
10015 using A::f; // #1
10016 using B<int>::g; // #2
10017 };
10019 In case #1 where `A::f' is a member template, DECL_ACCESS is
10020 recorded in the primary template but not in its specialization.
10021 We check access of FN using its primary template.
10023 In case #2, where `B<int>::g' has a DECL_TEMPLATE_INFO simply
10024 because it is a member of class template B, DECL_ACCESS is
10025 recorded in the specialization `B<int>::g'. We cannot use its
10026 primary template because `B<T>::g' and `B<int>::g' may have
10027 different access. */
10031 else
10036 }
10038 /* If we're checking for implicit delete, don't bother with argument
10039 conversions. */
10041 {
10045 /* Reject bad conversions now. */
10047 /* else continue to get conversion error. */
10048 }
10050 not_really_used:
10052 /* N3276 magic doesn't apply to nested calls. */
10055 /* No-Cleanup doesn't apply to nested calls either. */
10059 /* Find maximum size of vector to hold converted arguments. */
10066 in_consteval_if_p_temp_override icip;
10067 /* If the call is immediate function invocation, make sure
10068 taking address of immediate functions is allowed in its arguments. */
10078 {
10084 };
10086 /* The implicit parameters to a constructor are not considered by overload
10087 resolution, and must be of the proper type. */
10089 {
10093 /* We should never try to call the abstract constructor. */
10097 {
10101 }
10102 }
10103 /* Bypass access control for 'this' parameter. */
10105 {
10112 {
10114 {
10115 auto_diagnostic_group d;
10120 }
10121 else
10123 }
10125 /* The class where FN is defined. */
10128 /* See if the function member or the whole class type is declared
10129 final and the call can be devirtualized. */
10133 /* [class.mfct.non-static]: If a non-static member function of a class
10134 X is called for an object that is not of type X, or of a type
10135 derived from X, the behavior is undefined.
10137 So we can assume that anything passed as 'this' is non-null, and
10138 optimize accordingly. */
10139 /* Check that the base class is accessible. */
10142 {
10147 else
10149 }
10150 /* If fn was found by a using declaration, the conversion path
10151 will be to the derived class, not the base declaring fn. We
10152 must convert to the base. */
10155 {
10159 }
10161 /* If we know the dynamic type of the object, look up the final overrider
10162 in the BINFO. */
10165 {
10168 /* And unwind base_binfo to match. If we don't find the type we're
10169 looking for in BINFO_INHERITANCE_CHAIN, we're looking at diamond
10170 inheritance; for now do a normal virtual call in that case. */
10176 {
10180 }
10181 }
10188 }
10191 tree arg,
10195 {
10196 /* Set user_conv_p on the argument conversions, so rvalue/base handling
10197 knows not to allow any more UDCs. This needs to happen after we
10198 process cand->warnings. */
10202 tsubst_flags_t const arg_complain
10212 };
10215 {
10220 object_arg,
10221 param_index++,
10223 conversion_warning);
10227 else
10230 }
10235 {
10238 /* If the argument is NULL and used to (implicitly) instantiate a
10239 template function (and bind one of the template arguments to
10240 the type of 'long int'), we don't want to warn about passing NULL
10241 to non-pointer argument.
10242 For example, if we have this template function:
10244 template<typename T> void func(T x) {}
10246 we want to warn (when -Wconversion is enabled) in this case:
10248 void foo() {
10249 func<int>(NULL);
10250 }
10252 but not in this case:
10254 void foo() {
10255 func(NULL);
10256 }
10257 */
10264 current_arg,
10265 param_index,
10267 conversion_warning);
10271 else
10273 }
10275 /* Default arguments */
10277 {
10283 complain);
10287 }
10289 /* Ellipsis */
10292 {
10295 {
10296 /* Do no conversions for certain magic varargs. */
10300 }
10302 {
10303 /* Don't truncate excess precision to the semantic type. */
10306 /* For other magic varargs only do decay_conversion. */
10308 }
10312 {
10313 /* Avoid infinite recursion trying to call A(...). */
10315 /* Try to call the actual copy constructor for a good error. */
10318 }
10319 else
10324 }
10330 /* Avoid performing argument transformation if warnings are disabled.
10331 When tf_warning is set and at least one of the warnings is active
10332 the check_function_arguments function might warn about something. */
10336 && (warn_nonnull
10337 || warn_format
10338 || warn_suggest_attribute_format
10340 {
10344 {
10345 /* For -Wformat undo the implicit passing by hidden reference
10346 done by convert_arg_to_ellipsis. */
10350 else
10352 }
10356 }
10359 {
10360 /* Check for passing ellipsis arguments to an inherited constructor. We
10361 could handle this by open-coding the inherited constructor rather than
10362 defining it, but let's not bother now. */
10366 {
10368 {
10372 }
10374 }
10376 /* A base constructor inheriting from a virtual base doesn't get the
10377 inherited arguments, just this and __vtt. */
10380 }
10382 /* Avoid actually calling copy constructors and copy assignment operators,
10383 if possible. */
10386 && (!flag_elide_constructors
10387 /* It's unsafe to elide the operation when handling
10388 a noexcept-expression, it may evaluate to the wrong
10389 value (c++/53025, c++/96090). */
10395 {
10396 tree targ;
10401 /* Pull out the real argument, disregarding const-correctness. */
10403 /* Strip the reference binding for the constructor parameter. */
10407 /* But don't strip any other reference bindings; binding a temporary to a
10408 reference prevents copy elision. */
10414 {
10419 }
10420 else
10425 else
10428 /* In C++17 we shouldn't be copying a TARGET_EXPR except into a
10429 potentially-overlapping subobject. */
10432 || force_elide
10433 /* It's from binding the ref parm to a packed field. */
10436 /* See unsafe_copy_elision_p. */
10442 /* [class.copy]: the copy constructor is implicitly defined even if the
10443 implementation elided its use. But don't warn about deprecation when
10444 eliding a temporary, as then no copy is actually performed. */
10449 {
10453 }
10454 else
10461 /* If we're creating a temp and we already have one, don't create a
10462 new one. If we're not creating a temp but we get one, use
10463 INIT_EXPR to collapse the temp into our target. Otherwise, if the
10464 ctor is trivial, do a bitwise copy with a simple TARGET_EXPR for a
10465 temp or an INIT_EXPR otherwise. */
10467 {
10472 }
10475 {
10479 }
10480 }
10484 {
10492 {
10493 /* Avoid copying empty classes, but ensure op= returns an lvalue even
10494 if the object argument isn't one. This isn't needed in other cases
10495 since MODIFY_EXPR is always considered an lvalue. */
10500 }
10502 {
10506 "assignment from temporary %<initializer_list%> does "
10510 }
10511 else
10512 {
10513 /* We must only copy the non-tail padding parts. */
10522 build_index_type
10531 }
10536 }
10538 {
10542 {
10545 no_cleanup_complain);
10546 else
10548 }
10549 }
10557 /* Warn if the built-in writes to an object of a non-trivial type. */
10564 {
10565 tree t;
10572 complain);
10578 }
10579 else
10580 {
10581 /* If FN is marked deprecated or unavailable, then we've already
10582 issued a diagnostic from mark_used above, so avoid redundantly
10583 issuing another one from build_addr_func. */
10585 UNAVAILABLE_DEPRECATED_SUPPRESS);
10591 /* We're actually invoking the function. (Immediate functions get an
10592 & when invoking it even though the user didn't use &.) */
10594 }
10600 {
10602 /* build_new_op will clear this when appropriate. */
10604 }
10606 {
10610 }
10613 }
10615 namespace
10616 {
10618 /* Return the DECL of the first non-static subobject of class TYPE
10619 that satisfies the predicate PRED or null if none can be found. */
10622 tree
10624 {
10629 {
10636 }
10642 {
10648 }
10651 }
10653 struct NonPublicField
10654 {
10656 {
10658 }
10659 };
10661 /* Return the DECL of the first non-public subobject of class TYPE
10662 or null if none can be found. */
10666 {
10668 }
10670 struct NonTrivialField
10671 {
10673 {
10675 }
10676 };
10678 /* Return the DECL of the first non-trivial subobject of class TYPE
10679 or null if none can be found. */
10683 {
10685 }
10689 /* Return true if all copy and move assignment operator overloads for
10690 class TYPE are trivial and at least one of them is not deleted and,
10691 when ACCESS is set, accessible. Return false otherwise. Set
10692 HASASSIGN to true when the TYPE has a (not necessarily trivial)
10693 copy or move assignment. */
10695 static bool
10697 {
10701 /* Iterate over overloads of the assignment operator, checking
10702 accessible copy assignments for triviality. */
10705 {
10706 /* Skip operators that aren't copy assignments. */
10713 /* Skip template assignment operators and deleted functions. */
10723 /* Break early when both properties have been determined. */
10726 }
10728 /* Return true if they're all trivial and one of the expressions
10729 TYPE() = TYPE() or TYPE() = (TYPE&)() is valid. */
10734 }
10736 /* Return true if all copy and move ctor overloads for class TYPE are
10737 trivial and at least one of them is not deleted and, when ACCESS is
10738 set, accessible. Return false otherwise. Set each element of HASCTOR[]
10739 to true when the TYPE has a (not necessarily trivial) default and copy
10740 (or move) ctor, respectively. */
10742 static bool
10744 {
10749 {
10750 /* Skip template constructors. */
10756 /* Skip ctors other than default, copy, and move. */
10772 /* Break early when both properties have been determined. */
10775 }
10778 }
10780 /* Issue a warning on a call to the built-in function FNDECL if it is
10781 a raw memory write whose destination is not an object of (something
10782 like) trivial or standard layout type with a non-deleted assignment
10783 and copy ctor. Detects const correctness violations, corrupting
10784 references, virtual table pointers, and bypassing non-trivial
10785 assignments. */
10787 static void
10790 {
10791 /* Except for bcopy where it's second, the destination pointer is
10792 the first argument for all functions handled here. Compute
10793 the index of the destination and source arguments. */
10805 /* Determine the type of the pointed-to object and whether it's
10806 a complete class type. */
10812 /* Check to see if the raw memory call is made by a non-static member
10813 function with THIS as the destination argument for the destination
10814 type. If so, and if the class has no non-trivial bases or members,
10815 be more permissive. */
10818 /* ??? is_object_parameter? */
10820 {
10829 }
10831 /* True if the class is trivial. */
10834 /* Set to true if DESTYPE has an accessible copy assignment. */
10836 /* True if all of the class' overloaded copy assignment operators
10837 are all trivial (and not deleted) and at least one of them is
10838 accessible. */
10841 /* Set to true if DESTTYPE has an accessible default and copy ctor,
10842 respectively. */
10845 /* True if all of the class' overloaded copy constructors are all
10846 trivial (and not deleted) and at least one of them is accessible. */
10849 /* Set FLD to the first private/protected member of the class. */
10852 /* The warning format string. */
10854 /* A suggested alternative to offer instead of the raw memory call.
10855 Empty string when none can be come up with. */
10860 {
10863 {
10864 /* Diagnose setting non-copy-assignable or non-trivial types,
10865 or types with a private member, to (potentially) non-zero
10866 bytes. Since the value of the bytes being written is unknown,
10867 suggest using assignment instead (if one exists). Also warn
10868 for writes into objects for which zero-initialization doesn't
10869 mean all bits clear (pointer-to-member data, where null is all
10870 bits set). Since the value being written is (most likely)
10871 non-zero, simply suggest assignment (but not copy assignment). */
10879 {
10882 "%qD writing to an object of type %#qT with "
10885 }
10891 }
10892 /* Fall through. */
10895 /* Similarly to the above, diagnose clearing non-trivial or non-
10896 standard layout objects, or objects of types with no assignmenmt.
10897 Since the value being written is known to be zero, suggest either
10898 copy assignment, copy ctor, or default ctor as an alternative,
10899 depending on what's available. */
10922 /* Determine the type of the source object. */
10926 else
10929 /* Since it's impossible to determine wheter the byte copy is
10930 being used in place of assignment to an existing object or
10931 as a substitute for initialization, assume it's the former.
10932 Determine the best alternative to use instead depending on
10933 what's not deleted. */
10954 srctype))
10955 {
10956 /* Warn when copying into a non-trivial object from an object
10957 of a different type other than void or char. */
10959 "%qD copying an object of non-trivial type "
10962 }
10967 srctype))
10968 {
10971 "%qD copying an object of type %#qT with "
10972 "%qs member %qD from an array of %#qT; use "
10975 }
10977 {
10982 /* Finally, warn on partial copies. */
10983 unsigned HOST_WIDE_INT typesize
10991 "a non-trivial type %#qT leaves %wu "
10994 "a non-trivial type %#qT leaves %wu "
10997 }
11012 {
11016 /* Finally, warn on reallocation into insufficient space. */
11018 "%qD moving an object of non-trivial type "
11021 sz);
11022 }
11027 }
11030 {
11034 else
11037 }
11041 }
11043 /* Build and return a call to FN, using NARGS arguments in ARGARRAY.
11044 If FN is the result of resolving an overloaded target built-in,
11045 ORIG_FNDECL is the original function decl, otherwise it is null.
11046 This function performs no overload resolution, conversion, or other
11047 high-level operations. */
11049 tree
11052 {
11053 tree fndecl;
11055 /* Remember roughly where this call is. */
11064 /* Check that arguments to builtin functions match the expectations. */
11066 && !processing_template_decl
11068 {
11071 /* We need to take care that values to BUILT_IN_NORMAL
11072 are reduced. */
11080 {
11085 && same_type_ignoring_top_level_qualifiers_p
11088 /* For __builtin_clear_padding (&var) we know the type
11089 is for a complete object, so there is no risk in clearing
11092 {
11094 "argument %u in call to function %qE "
11098 }
11099 }
11100 }
11105 /* 5.2.2/11: If a function call is a prvalue of object type: if the
11106 function call is either the operand of a decltype-specifier or the
11107 right operand of a comma operator that is the operand of a
11108 decltype-specifier, a temporary object is not introduced for the
11109 prvalue. The type of the prvalue may be incomplete. */
11111 {
11117 {
11120 }
11121 }
11123 }
11125 /* Returns the value to use for the in-charge parameter when making a
11126 call to a function with the indicated NAME.
11128 FIXME:Can't we find a neater way to do this mapping? */
11130 tree
11132 {
11134 {
11138 }
11139 else
11140 {
11146 }
11149 }
11151 /* We've built up a constructor call RET. Complain if it delegates to the
11152 constructor we're currently compiling. */
11154 static void
11156 {
11162 }
11164 /* Build a call to a constructor, destructor, or an assignment
11165 operator for INSTANCE, an expression with class type. NAME
11166 indicates the special member function to call; *ARGS are the
11167 arguments. ARGS may be NULL. This may change ARGS. BINFO
11168 indicates the base of INSTANCE that is to be passed as the `this'
11169 parameter to the member function called.
11171 FLAGS are the LOOKUP_* flags to use when processing the call.
11173 If NAME indicates a complete object constructor, INSTANCE may be
11174 NULL_TREE. In this case, the caller will call build_cplus_new to
11175 store the newly constructed object into a VAR_DECL. */
11177 tree
11180 {
11181 tree fns;
11182 /* The type of the subobject to be constructed or destroyed. */
11183 tree class_type;
11185 tree ret;
11193 {
11196 /* Shortcut to avoid lazy destructor declaration. */
11198 }
11201 {
11202 /* Resolve the name. */
11207 }
11213 /* Handle the special case where INSTANCE is NULL_TREE. */
11216 else
11217 {
11218 /* Convert to the base class, if necessary. */
11221 {
11223 /* For constructors and destructors, either the base is
11224 non-virtual, or it is virtual but we are doing the
11225 conversion from a constructor or destructor for the
11226 complete object. In either case, we can convert
11227 statically. */
11229 else
11230 {
11231 /* However, for assignment operators, we must convert
11232 dynamically if the base is virtual. */
11236 }
11237 }
11238 }
11242 /* In C++17, "If the initializer expression is a prvalue and the
11243 cv-unqualified version of the source type is the same class as the class
11244 of the destination, the initializer expression is used to initialize the
11245 destination object." Handle that here to avoid doing overload
11246 resolution. */
11250 {
11261 && (same_type_ignoring_top_level_qualifiers_p
11263 {
11272 /* Avoid change of behavior on Wunused-var-2.C. */
11275 }
11276 }
11280 /* When making a call to a constructor or destructor for a subobject
11281 that uses virtual base classes, pass down a pointer to a VTT for
11282 the subobject. */
11286 {
11287 tree vtt;
11288 tree sub_vtt;
11290 /* If the current function is a complete object constructor
11291 or destructor, then we fetch the VTT directly.
11292 Otherwise, we look it up using the VTT we were given. */
11300 else
11304 {
11307 }
11310 }
11315 complain);
11326 }
11328 /* Return the NAME, as a C string. The NAME indicates a function that
11329 is a member of TYPE. *FREE_P is set to true if the caller must
11330 free the memory returned.
11332 Rather than go through all of this, we should simply set the names
11333 of constructors and destructors appropriately, and dispense with
11334 ctor_identifier, dtor_identifier, etc. */
11338 {
11341 /* Assume that we will not allocate memory. */
11343 /* Constructors and destructors are special. */
11345 {
11346 pretty_name
11348 /* For a destructor, add the '~'. */
11350 {
11352 /* Remember that we need to free the memory allocated. */
11354 }
11355 }
11357 {
11360 TFF_PLAIN_IDENTIFIER),
11361 NULL);
11362 /* Remember that we need to free the memory allocated. */
11364 }
11365 else
11369 }
11371 /* If CANDIDATES contains exactly one candidate, return it, otherwise
11372 return NULL. */
11376 {
11384 }
11386 /* If CANDIDATE is invalid due to a bad argument type, return the
11387 pertinent conversion_info.
11389 Otherwise, return NULL. */
11393 {
11394 /* Must be an rr_arg_conversion or rr_bad_arg_conversion. */
11401 {
11410 }
11411 }
11413 /* Issue an error and note complaining about a bad argument type at a
11414 callsite with a single candidate FNDECL.
11416 ARG_LOC is the location of the argument (or UNKNOWN_LOCATION, in which
11417 case input_location is used).
11418 FROM_TYPE is the type of the actual argument; TO_TYPE is the type of
11419 the formal parameter. */
11421 void
11425 {
11426 auto_diagnostic_group d;
11430 {
11433 }
11439 parmnum);
11440 }
11442 /* Subroutine of build_new_method_call_1, for where there are no viable
11443 candidates for the call. */
11445 static void
11448 tree explicit_targs,
11449 tree basetype,
11453 {
11454 auto_diagnostic_group d;
11461 else
11462 {
11463 /* Special-case for when there's a single candidate that's failing
11464 due to a bad argument type. */
11468 {
11476 }
11482 {
11485 }
11493 }
11495 }
11497 /* Build a call to "INSTANCE.FN (ARGS)". If FN_P is non-NULL, it will
11498 be set, upon return, to the function called. ARGS may be NULL.
11499 This may change ARGS. */
11501 tree
11505 {
11509 tree access_binfo;
11510 tree optype;
11512 tree name;
11515 tree call;
11516 tree fn;
11519 tree orig_instance;
11520 tree orig_fns;
11527 /* We don't know what function we're going to call, yet. */
11536 {
11540 }
11545 /* Dismantle the baselink to collect all the information we need. */
11552 {
11556 }
11565 /* Under DR 147 A::A() is an invalid constructor call,
11566 not a functional cast. */
11568 {
11574 auto_diagnostic_group d;
11582 complain);
11584 }
11589 /* Process the argument list. */
11591 {
11596 }
11598 /* Consider the object argument to be used even if we end up selecting a
11599 static member function. */
11602 /* Figure out whether to skip the first argument for the error
11603 message we will display to users if an error occurs. We don't
11604 want to display any compiler-generated arguments. The "this"
11605 pointer hasn't been added yet. However, we must remove the VTT
11606 pointer if this is a call to a base-class constructor or
11607 destructor. */
11610 {
11611 /* Callers should explicitly indicate whether they want to ctor
11612 the complete object or just the part without virtual bases. */
11615 /* Remove the VTT pointer, if present. */
11620 /* It's OK to call destructors and constructors on cv-qualified
11621 objects. Therefore, convert the INSTANCE to the unqualified
11622 type, if necessary. */
11624 {
11628 }
11629 }
11630 else
11633 /* For the overload resolution we need to find the actual `this`
11634 that would be captured if the call turns out to be to a
11635 non-static member function. Do not actually capture it at this
11636 point. */
11638 /* Constructors don't use the enclosing 'this'. */
11640 else
11643 conversion_obstack_sentinel cos;
11645 /* The number of arguments artificial parms in ARGS; we subtract one because
11646 there's no 'this' in ARGS. */
11649 /* If CONSTRUCTOR_IS_DIRECT_INIT is set, this was a T{ } form
11650 initializer, not T({ }). */
11654 {
11661 /* If the initializer list has no elements and T is a class type with
11662 a default constructor, the object is value-initialized. Handle
11663 this here so we don't need to handle it wherever we use
11664 build_special_member_call. */
11667 /* For a user-provided default constructor, use the normal
11668 mechanisms so that protected access works. */
11673 /* If BASETYPE is an aggregate, we need to do aggregate
11674 initialization. */
11676 {
11679 }
11682 {
11686 }
11688 /* Otherwise go ahead with overload resolution. */
11693 }
11694 else
11703 {
11704 /* [dcl.init], 17.6.2.2:
11706 Otherwise, if no constructor is viable, the destination type is
11707 a (possibly cv-qualified) aggregate class A, and the initializer
11708 is a parenthesized expression-list, the object is initialized as
11709 follows...
11711 We achieve this by building up a CONSTRUCTOR, as for list-init,
11712 and setting CONSTRUCTOR_IS_PAREN_INIT to distinguish between
11713 the two. */
11719 {
11720 /* Create a CONSTRUCTOR from ARGS, e.g. {1, 2} from <1, 2>. */
11722 user_args);
11727 else
11728 {
11733 }
11734 }
11739 skip_first_for_error,
11740 user_args);
11742 }
11743 else
11744 {
11747 {
11750 tree arglist;
11753 {
11758 auto_diagnostic_group d;
11762 else
11768 }
11772 }
11773 else
11774 {
11782 {
11783 /* This is not an error, it is runtime undefined
11784 behavior. */
11793 fn);
11794 }
11799 {
11804 {
11805 /* We captured 'this' in the current lambda now that
11806 we know we really need it. */
11808 }
11810 /* We can't tell until instantiation time whether we can use
11812 else
11813 {
11816 fn);
11818 }
11819 }
11822 {
11823 /* Now we know what function is being called. */
11826 /* Build the actual CALL_EXPR. */
11829 /* Suppress warnings for if (my_struct.operator= (x)) where
11830 my_struct is implicitly converted to bool. */
11834 /* In an expression of the form `a->f()' where `f' turns
11835 out to be a static member function, `a' is
11836 none-the-less evaluated. */
11842 /* An explicit call of the form "x->~X()" has type
11843 "void". However, on platforms where destructors
11844 return "this" (i.e., those where
11845 targetm.cxx.cdtor_returns_this is true), such calls
11846 will appear to have a return value of pointer type
11847 to the low-level call machinery. We do not want to
11848 change the low-level machinery, since we want to be
11849 able to optimize "delete f()" on such platforms as
11850 "operator delete(~X(f()))" (rather than generating
11851 "t = f(), ~X(t), operator delete (t)"). */
11853 }
11854 }
11855 }
11858 {
11864 {
11867 }
11871 /* Prune all but the selected function from the original overload
11872 set so that we can avoid some duplicate work at instantiation time. */
11874 {
11877 {
11878 /* Use the selected template, not the specialization, so that
11879 this looks like an actual lookup result for sake of
11880 filter_memfn_lookup. */
11883 /* If the original overload set consists of a single function
11884 template, this isn't beneficial. */
11890 }
11894 }
11896 skip_prune:
11897 call = (build_min_non_dep_call_vec
11901 orig_args));
11906 }
11912 }
11914 /* Returns true iff standard conversion sequence ICS1 is a proper
11915 subsequence of ICS2. */
11917 static bool
11919 {
11920 /* We can assume that a conversion of the same code
11921 between the same types indicates a subsequence since we only get
11922 here if the types we are converting from are the same. */
11929 {
11936 /* At this point, ICS1 cannot be a proper subsequence of
11937 ICS2. We can get a USER_CONV when we are comparing the
11938 second standard conversion sequence of two user conversion
11939 sequences. */
11954 }
11955 }
11957 /* Returns nonzero iff DERIVED is derived from BASE. The inputs may
11958 be any _TYPE nodes. */
11960 bool
11962 {
11966 /* We only allow proper derivation here. The DERIVED_FROM_P macro
11967 considers every class derived from itself. */
11970 }
11972 /* We build the ICS for an implicit object parameter as a pointer
11973 conversion sequence. However, such a sequence should be compared
11974 as if it were a reference conversion sequence. If ICS is the
11975 implicit conversion sequence for an implicit object parameter,
11976 modify it accordingly. */
11978 static void
11980 {
11982 {
11983 /* [over.match.funcs]
11985 For non-static member functions, the type of the
11986 implicit object parameter is "reference to cv X"
11987 where X is the class of which the function is a
11988 member and cv is the cv-qualification on the member
11989 function declaration. */
11991 tree reference_type;
11993 /* The `this' parameter is a pointer to a class type. Make the
11994 implicit conversion talk about a reference to that same class
11995 type. */
12008 }
12009 }
12011 /* If *ICS is a REF_BIND set *ICS to the remainder of the conversion,
12012 and return the initial reference binding conversion. Otherwise,
12013 leave *ICS unchanged and return NULL. */
12017 {
12019 {
12024 }
12027 }
12029 /* Get the expression at the beginning of the conversion chain C. */
12031 static tree
12033 {
12038 }
12040 /* Return a tree representing the number of elements initialized by the
12041 list-initialization C. The caller must check that C converts to an
12042 array type. */
12044 static tree
12046 {
12047 /* If the array we're converting to has a dimension, we'll use that. */
12050 else
12051 {
12052 /* Otherwise, we look at how many elements the constructor we're
12053 initializing from has. */
12056 }
12057 }
12059 /* True iff C is a conversion that binds a reference or a pointer to
12060 an array of unknown bound. */
12064 {
12065 /* ck_ref_bind won't have the reference stripped. */
12067 /* ck_qual won't have the pointer stripped. */
12071 }
12073 /* Compare two implicit conversion sequences according to the rules set out in
12074 [over.ics.rank]. Return values:
12076 1: ics1 is better than ics2
12077 -1: ics2 is better than ics1
12078 0: ics1 and ics2 are indistinguishable */
12080 static int
12082 {
12083 tree from_type1;
12084 tree from_type2;
12085 tree to_type1;
12086 tree to_type2;
12093 /* REF_BINDING is nonzero if the result of the conversion sequence
12094 is a reference type. In that case REF_CONV is the reference
12095 binding conversion. */
12099 /* Compare badness before stripping the reference conversion. */
12105 /* Handle implicit object parameters. */
12109 /* Handle reference parameters. */
12113 /* List-initialization sequence L1 is a better conversion sequence than
12114 list-initialization sequence L2 if L1 converts to
12115 std::initializer_list<X> for some X and L2 does not. */
12121 /* [over.ics.rank]
12123 When comparing the basic forms of implicit conversion sequences (as
12124 defined in _over.best.ics_)
12126 --a standard conversion sequence (_over.ics.scs_) is a better
12127 conversion sequence than a user-defined conversion sequence
12128 or an ellipsis conversion sequence, and
12130 --a user-defined conversion sequence (_over.ics.user_) is a
12131 better conversion sequence than an ellipsis conversion sequence
12132 (_over.ics.ellipsis_). */
12133 /* Use BAD_CONVERSION_RANK because we already checked for a badness
12134 mismatch. If both ICS are bad, we try to make a decision based on
12135 what would have happened if they'd been good. This is not an
12136 extension, we'll still give an error when we build up the call; this
12137 just helps us give a more helpful error message. */
12147 /* Both conversions are ellipsis conversions. */
12150 /* User-defined conversion sequence U1 is a better conversion sequence
12151 than another user-defined conversion sequence U2 if they contain the
12152 same user-defined conversion operator or constructor and if the sec-
12153 ond standard conversion sequence of U1 is better than the second
12154 standard conversion sequence of U2. */
12156 /* Handle list-conversion with the same code even though it isn't always
12157 ranked as a user-defined conversion and it doesn't have a second
12158 standard conversion sequence; it will still have the desired effect.
12159 Specifically, we need to do the reference binding comparison at the
12160 end of this function. */
12164 {
12171 {
12176 }
12177 /* List-initialization sequence L1 is a better conversion sequence than
12178 list-initialization sequence L2 if
12180 -- L1 and L2 convert to arrays of the same element type, and either
12181 the number of elements n1 initialized by L1 is less than the number
12182 of elements n2 initialized by L2, or n1=n2 and L2 converts to an array
12183 of unknown bound and L1 does not. (Added in CWG 1307 and extended by
12184 P0388R4.) */
12189 {
12196 /* The n1 == n2 case. */
12203 else
12205 }
12206 else
12207 {
12208 /* For ambiguous or aggregate conversions, use the target type as
12209 a proxy for the conversion function. */
12212 }
12214 /* We can just fall through here, after setting up
12215 FROM_TYPE1 and FROM_TYPE2. */
12218 }
12219 else
12220 {
12224 /* We're dealing with two standard conversion sequences.
12226 [over.ics.rank]
12228 Standard conversion sequence S1 is a better conversion
12229 sequence than standard conversion sequence S2 if
12231 --S1 is a proper subsequence of S2 (comparing the conversion
12232 sequences in the canonical form defined by _over.ics.scs_,
12233 excluding any Lvalue Transformation; the identity
12234 conversion sequence is considered to be a subsequence of
12235 any non-identity conversion sequence */
12246 }
12248 /* One sequence can only be a subsequence of the other if they start with
12249 the same type. They can start with different types when comparing the
12250 second standard conversion sequence in two user-defined conversion
12251 sequences. */
12253 {
12258 }
12260 /* [over.ics.rank]
12262 Or, if not that,
12264 --the rank of S1 is better than the rank of S2 (by the rules
12265 defined below):
12267 Standard conversion sequences are ordered by their ranks: an Exact
12268 Match is a better conversion than a Promotion, which is a better
12269 conversion than a Conversion.
12271 Two conversion sequences with the same rank are indistinguishable
12272 unless one of the following rules applies:
12274 --A conversion that does not a convert a pointer, pointer to member,
12275 or std::nullptr_t to bool is better than one that does.
12277 The ICS_STD_RANK automatically handles the pointer-to-bool rule,
12278 so that we do not have to check it explicitly. */
12287 /* A conversion from scalar arithmetic type to complex is worse than a
12288 conversion between scalar arithmetic types. */
12295 {
12298 else
12300 }
12302 {
12303 /* A conversion in either direction between floating-point type FP1 and
12304 floating-point type FP2 is better than a conversion in the same
12305 direction between FP1 and arithmetic type T3 if
12306 - the floating-point conversion rank of FP1 is equal to the rank of
12307 FP2, and
12308 - T3 is not a floating-point type, or T3 is a floating-point type
12309 whose rank is not equal to the rank of FP1, or the floating-point
12310 conversion subrank of FP2 is greater than the subrank of T3. */
12317 {
12320 }
12323 /* Only apply this rule if at least one of the 3 types is
12324 extended floating-point type, otherwise keep them as
12325 before for compatibility reasons with types like __float128.
12326 float, double and long double alone have different conversion
12327 ranks and so when just those 3 types are involved, this
12328 rule doesn't trigger. */
12332 {
12334 {
12337 }
12339 {
12340 /* cp_compare_floating_point_conversion_ranks returns -1, 0 or 1
12341 if the conversion rank is equal (-1 or 1 if the subrank is
12342 different). */
12344 fp2),
12346 {
12347 /* Conversion ranks of FP1 and FP2 are equal. */
12352 /* FP1 <-> FP2 conversion is better. */
12357 /* Conversion subrank of FP2 is greater than subrank of T3.
12358 FP1 <-> FP2 conversion is better. */
12361 /* Conversion subrank of FP2 is less than subrank of T3.
12362 FP1 <-> T3 conversion is better. */
12364 }
12369 /* Conversion ranks of FP1 and FP2 are not equal, conversion
12370 ranks of FP1 and T3 are equal.
12371 FP1 <-> T3 conversion is better. */
12373 }
12374 }
12375 }
12381 {
12386 }
12387 /* The rules for pointers to members A::* are just like the rules
12388 for pointers A*, except opposite: if B is derived from A then
12389 A::* converts to B::*, not vice versa. For that reason, we
12390 switch the from_ and to_ variables here. */
12397 {
12402 }
12407 {
12408 /* This was one of the pointer or pointer-like conversions.
12410 [over.ics.rank]
12412 --If class B is derived directly or indirectly from class A,
12413 conversion of B* to A* is better than conversion of B* to
12414 void*, and conversion of A* to void* is better than
12415 conversion of B* to void*. */
12418 {
12420 deref_from_type2))
12423 deref_from_type1))
12425 }
12428 {
12430 {
12432 {
12434 deref_to_type1))
12436 }
12437 /* We know that DEREF_TO_TYPE1 is `void' here. */
12439 deref_to_type2))
12441 }
12442 }
12445 {
12446 /* [over.ics.rank]
12448 --If class B is derived directly or indirectly from class A
12449 and class C is derived directly or indirectly from B,
12451 --conversion of C* to B* is better than conversion of C* to
12452 A*,
12454 --conversion of B* to A* is better than conversion of C* to
12455 A* */
12457 {
12459 deref_to_type2))
12462 deref_to_type1))
12464 }
12466 {
12468 deref_from_type1))
12471 deref_from_type2))
12473 }
12474 }
12475 }
12478 {
12481 /* [over.ics.rank]
12483 --binding of an expression of type C to a reference of type
12484 B& is better than binding an expression of type C to a
12485 reference of type A&
12487 --conversion of C to B is better than conversion of C to A, */
12490 {
12495 }
12496 }
12499 {
12502 /* [over.ics.rank]
12504 --binding of an expression of type B to a reference of type
12505 A& is better than binding an expression of type C to a
12506 reference of type A&,
12508 --conversion of B to A is better than conversion of C to A */
12511 {
12516 }
12517 }
12519 /* [over.ics.rank]
12521 --S1 and S2 differ only in their qualification conversion and yield
12522 similar types T1 and T2 (_conv.qual_), respectively, and the cv-
12523 qualification signature of type T1 is a proper subset of the cv-
12524 qualification signature of type T2 */
12528 {
12532 }
12534 /* [over.ics.rank]
12536 --S1 and S2 are reference bindings (_dcl.init.ref_) and neither refers
12537 to an implicit object parameter of a non-static member function
12538 declared without a ref-qualifier, and either S1 binds an lvalue
12539 reference to an lvalue and S2 binds an rvalue reference or S1 binds an
12540 rvalue reference to an rvalue and S2 binds an lvalue reference (C++0x
12541 draft standard, 13.3.3.2)
12543 --S1 and S2 are reference bindings (_dcl.init.ref_), and the
12544 types to which the references refer are the same type except for
12545 top-level cv-qualifiers, and the type to which the reference
12546 initialized by S2 refers is more cv-qualified than the type to
12547 which the reference initialized by S1 refers.
12549 DR 1328 [over.match.best]: the context is an initialization by
12550 conversion function for direct reference binding (13.3.1.6) of a
12551 reference to function type, the return type of F1 is the same kind of
12552 reference (i.e. lvalue or rvalue) as the reference being initialized,
12553 and the return type of F2 is not. */
12556 {
12563 {
12567 /* Don't prefer a bad conversion that drops cv-quals to a bad
12568 conversion with the wrong rvalueness. */
12572 }
12575 {
12576 /* Per P0388R4:
12578 void f (int(&)[]), // (1)
12579 f (int(&)[1]), // (2)
12580 f (int*); // (3)
12582 (2) is better than (1), but (3) should be equal to (1) and to
12583 (2). For that reason we don't use ck_qual for (1) which would
12584 give it the cr_exact rank while (3) remains ck_identity.
12585 Therefore we compare (1) and (2) here. For (1) we'll have
12587 ck_ref_bind <- ck_identity
12588 int[] & int[1]
12590 so to handle this we must look at ref_conv. */
12601 {
12602 /* Prefer the one that drops fewer cv-quals. */
12607 }
12609 }
12610 }
12612 /* [over.ics.rank]
12614 Per CWG 1601:
12615 -- A conversion that promotes an enumeration whose underlying type
12616 is fixed to its underlying type is better than one that promotes to
12617 the promoted underlying type, if the two are different. */
12623 {
12627 {
12634 }
12635 }
12637 /* Neither conversion sequence is better than the other. */
12639 }
12641 /* The source type for this standard conversion sequence. */
12643 static tree
12645 {
12647 }
12649 /* Note a warning about preferring WINNER to LOSER. We do this by storing
12650 a pointer to LOSER and re-running joust to produce the warning if WINNER
12651 is actually used. */
12653 static void
12655 {
12661 }
12663 /* CAND is a constructor candidate in joust in C++17 and up. If it copies a
12664 prvalue returned from a conversion function, return true. Otherwise, return
12665 false. */
12667 static bool
12669 {
12679 {
12685 }
12687 }
12689 /* True if the defining declarations of the two candidates have equivalent
12690 parameters. */
12692 static bool
12694 {
12701 /* We don't look at c1->template_decl because that's only set for primary
12702 templates, not e.g. non-template member functions of class templates. */
12706 {
12713 }
12719 else
12721 };
12727 {
12728 /* Ignore 'this' when comparing the parameters of a static member
12729 function with those of a non-static one. */
12732 }
12737 {
12739 /* CWG2789 is not adequate, it should specify corresponding object
12740 parameters, not same typed object parameters. */
12743 /* We just compared the object parameters, if they don't correspond
12744 we already return false. */
12747 }
12749 }
12751 /* True iff FN is a copy or move constructor or assignment operator. */
12753 static bool
12755 {
12760 }
12762 /* Compare two candidates for overloading as described in
12763 [over.match.best]. Return values:
12765 1: cand1 is better than cand2
12766 -1: cand2 is better than cand1
12767 0: cand1 and cand2 are indistinguishable */
12769 static int
12771 tsubst_flags_t complain)
12772 {
12778 /* Candidates that involve bad conversions are always worse than those
12779 that don't. */
12785 /* If we have two pseudo-candidates for conversions to the same type,
12786 or two candidates for the same function, arbitrarily pick one. */
12792 /* Prefer a non-deleted function over an implicitly deleted move
12793 constructor or assignment operator. This differs slightly from the
12794 wording for issue 1402 (which says the move op is ignored by overload
12795 resolution), but this way produces better error messages. */
12799 {
12806 }
12808 /* a viable function F1
12809 is defined to be a better function than another viable function F2 if
12810 for all arguments i, ICSi(F1) is not a worse conversion sequence than
12811 ICSi(F2), and then */
12813 /* for some argument j, ICSj(F1) is a better conversion sequence than
12814 ICSj(F2) */
12816 /* For comparing static and non-static member functions, we ignore
12817 the implicit object parameter of the non-static function. The
12818 standard says to pretend that the static function has an object
12819 parm, but that won't work with operator overloading. */
12822 {
12832 /* We're comparing a near-match list constructor and a near-match
12833 non-list constructor. Just treat them as unordered. */
12839 {
12840 /* C++23 [over.best.ics.general] says:
12841 When the parameter is the implicit object parameter of a static
12842 member function, the implicit conversion sequence is a standard
12843 conversion sequence that is neither better nor worse than any
12844 other standard conversion sequence. */
12848 }
12849 else
12850 {
12855 }
12856 }
12859 {
12865 {
12867 && warn_sign_promo
12879 {
12886 else
12891 {
12895 }
12896 else
12898 }
12901 {
12902 /* Ambiguity between normal and reversed comparison operators
12903 with the same parameter types. P2468 decided not to go with
12904 this approach to resolving the ambiguity, so pedwarn. */
12908 {
12912 else
12915 {
12916 auto_diagnostic_group d;
12918 "C++20 says that these are ambiguous, "
12920 {
12929 {
12930 /* Suggest adding const to
12931 struct A { bool operator==(const A&); }; */
12932 tree parmtype
12937 && (same_type_ignoring_top_level_qualifiers_p
12941 "try making the operator a %<const%> "
12943 }
12944 }
12945 }
12946 else
12949 }
12953 }
12955 }
12956 }
12958 /* warn about confusing overload resolution for user-defined conversions,
12959 either between a constructor and a conversion op, or between two
12960 conversion ops. */
12962 /* In C++17, the constructor might have been elided, which means that
12963 an originally null ->second_conv could become non-null. */
12967 {
12973 else
12976 /* We don't want to complain about `X::operator T1 ()'
12977 beating `X::operator T2 () const', when T2 is a no less
12978 cv-qualified version of T1. */
12981 {
12986 {
12989 }
12992 }
12993 else
12999 {
13003 auto_diagnostic_group d;
13007 {
13010 }
13011 }
13012 else
13014 }
13019 /* DR 495 moved this tiebreaker above the template ones. */
13020 /* or, if not that,
13021 the context is an initialization by user-defined conversion (see
13022 _dcl.init_ and _over.match.user_) and the standard conversion
13023 sequence from the return type of F1 to the destination type (i.e.,
13024 the type of the entity being initialized) is a better conversion
13025 sequence than the standard conversion sequence from the return type
13026 of F2 to the destination type. */
13029 {
13033 }
13035 /* CWG2735 (PR109247): A copy/move ctor/op= for which its operand uses an
13036 explicit conversion (due to list-initialization) is worse. */
13037 {
13044 {
13052 }
13053 }
13055 /* DR2327: C++17 copy elision in [over.match.ctor] (direct-init) context.
13056 The standard currently says that only constructors are candidates, but if
13057 one copies a prvalue returned by a conversion function we prefer that.
13059 Clang does something similar, as discussed at
13060 http://lists.isocpp.org/core/2017/10/3166.php
13061 http://lists.isocpp.org/core/2019/03/5721.php */
13066 {
13072 }
13074 /* or, if not that,
13075 F1 is a non-template function and F2 is a template function
13076 specialization. */
13083 /* or, if not that,
13084 F1 and F2 are template functions and the function template for F1 is
13085 more specialized than the template for F2 according to the partial
13086 ordering rules. */
13089 {
13090 winner = more_specialized_fn
13093 /* [temp.func.order]: The presence of unused ellipsis and default
13094 arguments has no effect on the partial ordering of function
13095 templates. add_function_candidate() will not have
13096 counted the "this" argument for constructors. */
13100 }
13102 /* Concepts: F1 and F2 are non-template functions with the same
13103 parameter-type-lists, and F1 is more constrained than F2 according to the
13104 partial ordering of constraints described in 13.5.4. */
13109 {
13113 }
13115 /* F2 is a rewritten candidate (12.4.1.2) and F1 is not, or F1 and F2 are
13116 rewritten candidates, and F2 is a synthesized candidate with reversed
13117 order of parameters and F1 is not. */
13119 {
13126 }
13130 /* F1 is generated from a deduction-guide (13.3.1.8) and F2 is not */
13132 {
13134 /* We distinguish between candidates from an explicit deduction guide and
13135 candidates built from a constructor based on DECL_ARTIFICIAL. */
13142 {
13143 /* Prefer the special copy guide over a declared copy/move
13144 constructor. */
13150 /* Prefer a candidate generated from a non-template constructor. */
13155 }
13156 }
13158 /* F1 is a member of a class D, F2 is a member of a base class B of D, and
13159 for all arguments the corresponding parameters of F1 and F2 have the same
13160 type (CWG 2273/2277). */
13165 {
13179 {
13181 {
13186 }
13189 }
13190 }
13192 /* Check whether we can discard a builtin candidate, either because we
13193 have two identical ones or matching builtin and non-builtin candidates.
13195 (Pedantically in the latter case the builtin which matched the user
13196 function should not be added to the overload set, but we spot it here.
13198 [over.match.oper]
13199 ... the builtin candidates include ...
13200 - do not have the same parameter type list as any non-template
13201 non-member candidate. */
13204 {
13210 {
13212 /* Two built-in candidates; arbitrarily pick one. */
13215 /* cand1 is built-in; prefer cand2. */
13217 else
13218 /* cand2 is built-in; prefer cand1. */
13220 }
13221 }
13223 /* For candidates of a multi-versioned function, make the version with
13224 the highest priority win. This version will be checked for dispatching
13225 first. If this version can be inlined into the caller, the front-end
13226 will simply make a direct call to this function. */
13232 {
13238 /* Check if cand1->fn and cand2->fn are versions of the same function. It
13239 is possible that cand1->fn and cand2->fn are function versions but of
13240 different functions. Check types to see if they are versions of the same
13241 function. */
13244 {
13245 /* Always make the version with the higher priority, more
13246 specialized, win. */
13250 else
13252 }
13253 }
13255 /* If the two function declarations represent the same function (this can
13256 happen with declarations in multiple scopes and arg-dependent lookup),
13257 arbitrarily choose one. But first make sure the default args we're
13258 using match. */
13261 {
13268 {
13269 /* Don't crash if the fn is variadic. */
13274 }
13282 {
13285 {
13287 {
13289 {
13290 auto_diagnostic_group d;
13292 "default argument mismatch in "
13294 {
13299 }
13300 }
13301 else
13303 }
13304 else
13307 }
13310 }
13313 }
13315 tweak:
13317 /* Extension: If the worst conversion for one candidate is better than the
13318 worst conversion for the other, take the first. */
13320 {
13325 {
13330 }
13336 {
13337 /* Don't choose a deleted function over ambiguity. */
13341 {
13342 auto_diagnostic_group d;
13344 "ISO C++ says that these are ambiguous, even "
13345 "though the worst conversion for the first is "
13347 {
13350 }
13351 }
13352 else
13355 }
13356 }
13360 }
13362 /* Given a list of candidates for overloading, find the best one, if any.
13363 This algorithm has a worst case of O(2n) (winner is last), and a best
13364 case of O(n/2) (totally ambiguous); much better than a sorting
13365 algorithm. The candidates list is assumed to be sorted according
13366 to viability (via splice_viable). */
13370 {
13375 /* Walk through the list once, comparing each current champ to the next
13376 candidate, knocking out a candidate or two with each comparison. */
13379 {
13384 {
13388 }
13389 else
13390 {
13394 {
13397 }
13399 }
13400 }
13402 /* Make sure the champ is better than all the candidates it hasn't yet
13403 been compared to. */
13409 {
13411 /* We already know this candidate is worse than the champ. */
13415 {
13418 }
13419 }
13424 /* Move the champ to the front of the candidate list. */
13427 {
13432 }
13435 }
13437 /* Returns nonzero if things of type FROM can be converted to TO. */
13439 bool
13441 {
13443 /* implicit_conversion only considers user-defined conversions
13444 if it has an expression for the call argument list. */
13448 }
13450 /* Returns nonzero if things of type FROM can be converted to TO with a
13451 standard conversion. */
13453 bool
13455 {
13457 }
13459 /* Returns nonzero if ARG (of type FROM) can be converted to TO. */
13461 bool
13463 tsubst_flags_t complain)
13464 {
13468 conversion_obstack_sentinel cos;
13469 /* We want to discard any access checks done for this test,
13470 as we might not be in the appropriate access context and
13471 we'll do the check again when we actually perform the
13472 conversion. */
13479 /* Discard the access checks now. */
13483 }
13485 /* Like can_convert_arg, but allows dubious conversions as well. */
13487 bool
13489 tsubst_flags_t complain)
13490 {
13493 conversion_obstack_sentinel cos;
13494 /* Try to perform the conversion. */
13499 }
13501 /* Return an IMPLICIT_CONV_EXPR from EXPR to TYPE with bits set from overload
13502 resolution FLAGS. */
13504 tree
13506 {
13507 /* In a template, we are only concerned about determining the
13508 type of non-dependent expressions, so we do not have to
13509 perform the actual conversion. But for initializers, we
13510 need to be able to perform it at instantiation
13511 (or instantiate_non_dependent_expr) time. */
13518 }
13520 /* Convert EXPR to TYPE. Return the converted expression.
13522 Note that we allow bad conversions here because by the time we get to
13523 this point we are committed to doing the conversion. If we end up
13524 doing a bad conversion, convert_like will complain. */
13526 tree
13529 {
13535 else
13541 conversion_obstack_sentinel cos;
13548 {
13552 }
13555 else
13556 {
13557 /* Give a conversion call the same location as expr. */
13560 }
13563 }
13565 tree
13567 {
13569 LOOKUP_IMPLICIT);
13570 }
13572 /* Convert EXPR to TYPE (as a direct-initialization) if that is
13573 permitted. If the conversion is valid, the converted expression is
13574 returned. Otherwise, NULL_TREE is returned, except in the case
13575 that TYPE is a class type; in that case, an error is issued. If
13576 C_CAST_P is true, then this direct-initialization is taking
13577 place as part of a static_cast being attempted as part of a C-style
13578 cast. */
13580 tree
13582 tree expr,
13584 tsubst_flags_t complain)
13585 {
13590 /* [dcl.init]
13592 If the destination type is a (possibly cv-qualified) class type:
13594 -- If the initialization is direct-initialization ...,
13595 constructors are considered.
13597 -- If overload resolution is successful, the selected constructor
13598 is called to initialize the object, with the initializer expression
13599 or expression-list as its argument(s).
13601 -- Otherwise, if no constructor is viable, the destination type is
13602 a (possibly cv-qualified) aggregate class A, and the initializer is
13603 a parenthesized expression-list, the object is initialized as
13604 follows... */
13606 {
13611 }
13613 conversion_obstack_sentinel cos;
13616 c_cast_p,
13621 {
13622 /* In a template, we are only concerned about determining the
13623 type of non-dependent expressions, so we do not have to
13624 perform the actual conversion. But for initializers, we
13625 need to be able to perform it at instantiation
13626 (or instantiate_non_dependent_expr) time. */
13629 }
13630 else
13636 }
13638 /* When initializing a reference that lasts longer than a full-expression,
13639 this special rule applies:
13641 [class.temporary]
13643 The temporary to which the reference is bound or the temporary
13644 that is the complete object to which the reference is bound
13645 persists for the lifetime of the reference.
13647 The temporaries created during the evaluation of the expression
13648 initializing the reference, except the temporary to which the
13649 reference is bound, are destroyed at the end of the
13650 full-expression in which they are created.
13652 In that case, we store the converted expression into a new
13653 VAR_DECL in a new scope.
13655 However, we want to be careful not to create temporaries when
13656 they are not required. For example, given:
13658 struct B {};
13659 struct D : public B {};
13660 D f();
13661 const B& b = f();
13663 there is no need to copy the return value from "f"; we can just
13664 extend its lifetime. Similarly, given:
13666 struct S {};
13667 struct T { operator S(); };
13668 T t;
13669 const S& s = t;
13671 we can extend the lifetime of the return value of the conversion
13672 operator.
13674 The next several functions are involved in this lifetime extension. */
13676 /* DECL is a VAR_DECL or FIELD_DECL whose type is a REFERENCE_TYPE. The
13677 reference is being bound to a temporary. Create and return a new
13678 VAR_DECL with the indicated TYPE; this variable will store the value to
13679 which the reference is bound. */
13681 tree
13683 {
13686 /* Register the variable. */
13689 {
13690 /* Namespace-scope or local static; give it a mangled name. */
13692 /* If an initializer is visible to multiple translation units, those
13693 translation units must agree on the addresses of the
13694 temporaries. Therefore the temporaries must be given a consistent name
13695 and vague linkage. The mangled name of a temporary is the name of the
13696 non-temporary object in whose initializer they appear, prefixed with
13697 GR and suffixed with a sequence number mangled using the usual rules
13698 for a seq-id. Temporaries are numbered with a pre-order, depth-first,
13699 left-to-right walk of the complete initializer. */
13705 }
13706 else
13707 /* Create a new cleanup level if necessary. */
13711 }
13713 /* EXPR is the initializer for a variable DECL of reference or
13714 std::initializer_list type. Create, push and return a new VAR_DECL
13715 for the initializer so that it will live as long as DECL. Any
13716 cleanup for the new variable is returned through CLEANUP, and the
13717 code to initialize the new variable is returned through INITP. */
13719 static tree
13722 {
13723 tree init;
13724 tree type;
13725 tree var;
13727 /* Create the temporary variable. */
13731 /* If the rvalue is the result of a function call it will be
13732 a TARGET_EXPR. If it is some other construct (such as a
13733 member access expression where the underlying object is
13734 itself the result of a function call), turn it into a
13735 TARGET_EXPR here. It is important that EXPR be a
13736 TARGET_EXPR below since otherwise the INIT_EXPR will
13737 attempt to make a bitwise copy of EXPR to initialize
13738 VAR. */
13741 else
13742 {
13747 }
13751 {
13755 }
13757 /* Recursively extend temps in this initializer. */
13760 cond_guard);
13762 /* Any reference temp has a non-trivial initializer. */
13765 /* If the initializer is constant, put it in DECL_INITIAL so we get
13766 static initialization and use in constant expressions. */
13768 /* As in store_init_value. */
13771 {
13773 {
13774 /* 5.19 says that a constant expression can include an
13775 lvalue-rvalue conversion applied to "a glvalue of literal type
13776 that refers to a non-volatile temporary object initialized
13777 with a constant expression". Rather than try to communicate
13778 that this VAR_DECL is a temporary, just mark it constexpr. */
13783 }
13786 }
13787 else
13788 /* Create the INIT_EXPR that will initialize the temporary
13789 variable. */
13792 {
13797 else
13798 {
13801 {
13803 {
13805 {
13810 boolean_false_node,
13811 tf_warning_or_error);
13813 }
13816 }
13818 }
13819 }
13821 /* We must be careful to destroy the temporary only
13822 after its initialization has taken place. If the
13823 initialization throws an exception, then the
13824 destructor should not be run. We cannot simply
13825 transform INIT into something like:
13827 (INIT, ({ CLEANUP_STMT; }))
13829 because emit_local_var always treats the
13830 initializer as a full-expression. Thus, the
13831 destructor would run too early; it would run at the
13832 end of initializing the reference variable, rather
13833 than at the end of the block enclosing the
13834 reference variable.
13836 The solution is to pass back a cleanup expression
13837 which the caller is responsible for attaching to
13838 the statement tree. */
13839 }
13840 else
13841 {
13844 {
13847 tls_aggregates);
13848 else
13850 static_aggregates);
13851 }
13852 else
13853 /* Check whether the dtor is callable. */
13855 }
13856 /* Avoid -Wunused-variable warning (c++/38958). */
13863 }
13865 /* Convert EXPR to the indicated reference TYPE, in a way suitable for
13866 initializing a variable of that TYPE. */
13868 tree
13871 {
13878 conversion_obstack_sentinel cos;
13882 /* If this conversion failed, we're in C++20, and we have something like
13883 A& a(b) where A is an aggregate, try again, this time as A& a{b}. */
13886 {
13892 /* If this worked, use it. */
13895 }
13897 {
13899 {
13908 else
13912 }
13914 }
13917 /* Perform the conversion. */
13920 /* We gave an error in build_user_type_conversion_1. */
13922 else
13926 }
13928 /* Return true if T is std::pair<const T&, const T&>. */
13930 static bool
13932 {
13933 /* First, check if we have std::pair. */
13944 /* Now see if the template arguments are both const T&. */
13954 }
13956 /* Return true if a class CTYPE is either std::reference_wrapper or
13957 std::ref_view, or a reference wrapper class. We consider a class
13958 a reference wrapper class if it has a reference member. We no
13959 longer check that it has a constructor taking the same reference type
13960 since that approach still generated too many false positives. */
13962 static bool
13964 {
13966 fields;
13973 }
13975 /* A wrapper for the above suitable as a callback for dfs_walk_once. */
13977 static tree
13979 {
13982 }
13984 static bool
13986 {
13990 /* Also accept a std::pair<const T&, const T&>. */
13996 {
14003 }
14005 /* Some classes, such as std::tuple, have the reference member in its
14006 (non-direct) base class. */
14012 }
14014 /* Helper for maybe_warn_dangling_reference to find a problematic CALL_EXPR
14015 that initializes the LHS (and at least one of its arguments represents
14016 a temporary, as outlined in maybe_warn_dangling_reference), or NULL_TREE
14017 if none found. For instance:
14019 const S& s = S().self(); // S::self (&TARGET_EXPR <...>)
14020 const int& r = (42, f(1)); // f(1)
14021 const int& t = b ? f(1) : f(2); // f(1)
14022 const int& u = b ? f(1) : f(g); // f(1)
14023 const int& v = b ? f(g) : f(2); // f(2)
14024 const int& w = b ? f(g) : f(g); // NULL_TREE
14025 const int& y = (f(1), 42); // NULL_TREE
14026 const int& z = f(f(1)); // f(f(1))
14028 EXPR is the initializer. If ARG_P is true, we're processing an argument
14029 to a function; the point is to distinguish between, for example,
14031 Ref::inner (&TARGET_EXPR <D.2839, F::foo (fm)>)
14033 where we shouldn't warn, and
14035 Ref::inner (&TARGET_EXPR <D.2908, F::foo (&TARGET_EXPR <...>)>)
14037 where we should warn (Ref is a reference_like_class_p so we see through
14038 it. */
14040 static tree
14042 {
14046 {
14047 /* An attempt to reduce the number of -Wdangling-reference
14048 false positives concerning reference wrappers (c++/107532).
14049 When we encounter a reference_like_class_p, we don't warn
14050 just yet; instead, we keep recursing to see if there were
14051 any temporaries behind the reference-wrapper class. */
14057 }
14060 {
14062 {
14067 OPT_Wdangling_reference)
14068 /* Don't emit a false positive for:
14069 std::vector<int> v = ...;
14070 std::vector<int>::const_iterator it = v.begin();
14071 const int &r = *it++;
14072 because R refers to one of the int elements of V, not to
14073 a temporary object. Member operator* may return a reference
14074 but probably not to one of its arguments. */
14081 /* If the function doesn't return a reference, don't warn. This
14082 can be e.g.
14083 const int& z = std::min({1, 2, 3, 4, 5, 6, 7});
14084 which doesn't dangle: std::min here returns an int.
14086 If the function returns a std::pair<const T&, const T&>, we
14087 warn, to detect e.g.
14088 std::pair<const int&, const int&> v = std::minmax(1, 2);
14089 which also creates a dangling reference, because std::minmax
14090 returns std::pair<const T&, const T&>(b, a). */
14094 /* Here we're looking to see if any of the arguments is a temporary
14095 initializing a reference parameter. */
14097 {
14099 /* Check that this argument initializes a reference, except for
14100 the argument initializing the object of a member function. */
14107 /* Recurse to see if the argument is a temporary. It could also
14108 be another call taking a temporary and returning it and
14109 initializing this reference parameter. */
14112 /* Don't warn about member function like:
14113 std::any a(...);
14114 S& s = a.emplace<S>({0}, 0);
14115 which constructs a new object and returns a reference to it, but
14116 we still want to detect:
14117 struct S { const S& self () { return *this; } };
14118 const S& s = S().self();
14119 where 's' dangles. If we've gotten here, the object this function
14120 is invoked on is not a temporary. */
14123 }
14125 }
14138 }
14139 }
14141 /* Implement -Wdangling-reference, to detect cases like
14143 int n = 1;
14144 const int& r = std::max(n - 1, n + 1); // r is dangling
14146 This creates temporaries from the arguments, returns a reference to
14147 one of the temporaries, but both temporaries are destroyed at the end
14148 of the full expression.
14150 This works by checking if a reference is initialized with a function
14151 that returns a reference, and at least one parameter of the function
14152 is a reference that is bound to a temporary. It assumes that such a
14153 function actually returns one of its arguments.
14155 DECL is the reference being initialized, INIT is the initializer. */
14157 static void
14159 {
14163 /* Only warn if what we're initializing has type T&& or const T&, or
14164 std::pair<const T&, const T&>. (A non-const lvalue reference can't
14165 bind to a temporary.) */
14171 /* Don't suppress the diagnostic just because the call comes from
14172 a system header. If the DECL is not in a system header, or if
14173 -Wsystem-headers was provided, warn. */
14174 auto wsh
14179 {
14180 auto_diagnostic_group d;
14185 }
14186 }
14188 /* If *P is an xvalue expression, prevent temporary lifetime extension if it
14189 gets used to initialize a reference. */
14191 static tree
14193 {
14199 /* Change a TARGET_EXPR from prvalue to xvalue. */
14204 }
14206 /* Subroutine of extend_ref_init_temps. Possibly extend one initializer,
14207 which is bound either to a reference or a std::initializer_list. */
14209 static tree
14212 {
14213 /* CWG1299 (C++20): The temporary object to which the reference is bound or
14214 the temporary object that is the complete object of a subobject to which
14215 the reference is bound persists for the lifetime of the reference if the
14216 glvalue to which the reference is bound was obtained through one of the
14217 following:
14218 - a temporary materialization conversion ([conv.rval]),
14219 - ( expression ), where expression is one of these expressions,
14220 - subscripting ([expr.sub]) of an array operand, where that operand is one
14221 of these expressions,
14222 - a class member access ([expr.ref]) using the . operator where the left
14223 operand is one of these expressions and the right operand designates a
14224 non-static data member of non-reference type,
14225 - a pointer-to-member operation ([expr.mptr.oper]) using the .* operator
14226 where the left operand is one of these expressions and the right operand
14227 is a pointer to data member of non-reference type,
14228 - a const_cast ([expr.const.cast]), static_cast ([expr.static.cast]),
14229 dynamic_cast ([expr.dynamic.cast]), or reinterpret_cast
14230 ([expr.reinterpret.cast]) converting, without a user-defined conversion,
14231 a glvalue operand that is one of these expressions to a glvalue that
14232 refers to the object designated by the operand, or to its complete
14233 object or a subobject thereof,
14234 - a conditional expression ([expr.cond]) that is a glvalue where the
14235 second or third operand is one of these expressions, or
14236 - a comma expression ([expr.comma]) that is a glvalue where the right
14237 operand is one of these expressions. */
14239 /* FIXME several cases are still handled wrong (101572, 81420). */
14245 {
14248 cond_guard);
14250 }
14254 {
14255 /* A pointer-to-member operation. */
14258 cond_guard);
14260 }
14262 {
14269 {
14272 tf_warning_or_error);
14275 tf_warning_or_error);
14276 }
14283 {
14286 tf_warning_or_error);
14289 tf_warning_or_error);
14290 }
14292 }
14295 /* Deal with binding to a subobject. */
14300 {
14308 }
14310 }
14312 /* INIT is part of the initializer for DECL. If there are any
14313 reference or initializer lists being initialized, extend their
14314 lifetime to match that of DECL. */
14316 tree
14319 {
14328 else
14329 {
14334 {
14335 /* [dcl.init] When initializing an aggregate from a parenthesized list
14336 of values... a temporary object bound to a reference does not have
14337 its lifetime extended. */
14342 {
14343 /* The temporary array underlying a std::initializer_list
14344 is handled like a reference temporary. */
14347 cond_guard);
14349 }
14350 else
14351 {
14357 cond_guard);
14358 }
14362 }
14363 }
14366 }
14368 /* Returns true iff an initializer for TYPE could contain temporaries that
14369 need to be extended because they are bound to references or
14370 std::initializer_list. */
14372 bool
14374 {
14379 {
14386 }
14388 }
14390 /* Returns true iff TYPE is some variant of std::initializer_list. */
14392 bool
14394 {
14399 /* Look through typedefs. */
14404 }
14406 /* Returns true iff DECL is a list constructor: i.e. a constructor which
14407 will accept an argument list of a single std::initializer_list<T>. */
14409 bool
14411 {
14413 tree arg;
14425 /* There are more non-defaulted parms. */
14429 }
14431 /* We know that can_convert_arg_bad already said "no" when trying to convert
14432 FROM to TO with ARG and FLAGS. Try to figure out if it was because
14433 an explicit conversion function was skipped when looking for a way to
14434 perform the conversion. At this point we've already printed an error. */
14436 void
14438 {
14442 conversion_obstack_sentinel cos;
14446 /* Ay, the conversion would have worked in direct-init context. */
14453 }