gcc/cp/call.c

18 You should have received a copy of the GNU General Public License
291   /* We have to do these by hand to avoid real pointer to member
389 	 functions.  These may have been declared normally if
820   /* Within a list-initialization we can have more user-defined
1309 	 conversions have been already handled above).  */
1569      reference compatible.  We have do do this after stripping
1798      have 'complain &= ~(tf_warning|tf_error)' because it would cause
1963      explicitly declared, except for friend functions which will have
1986      First, to be a viable function, a candidate function shall have enough
2753       /* Or if they have different forms.  */
3105      have that form.  */
3332 print_arity_information (location_t loc, unsigned int have, unsigned int want)
3337 	    want, have);
3344    to have been run through gettext by the caller.  This wart makes
3439 	  /* This candidate didn't have any issues or we failed to
3472      checking this condition as long as possible, since we have no way
3757 	      /* 13.3.1.6 doesn't have a parallel restriction, but it should;
3774 		 second standard conversion sequence shall have exact match
3975    The ARGS should already have gone through RESOLVE_ARGS before this
4518      If E1 and E2 have class type, and the underlying class types are
4546        converted to the type that expression E2 would have if E2 were
4637 	     but the warnings (like Wsign-conversion) have already been
4737 	 since it can't have any effect and since decay_conversion
4754 	 --Both the second and the third operands have type void; the
4809      Otherwise, if the second and third operand have different types,
4848 	      error_at (loc, "operands to ?: have different types %qT and %qT",
4866 	     "volatile X", and X does not have a copy constructor
4889       /* If, after the conversion, both operands have class type,
4916      category and have the same type, the result is of that type and
4931      operand do not have the same type, and either has (possibly
4964 	    error_at (loc, "operands to ?: have different types %qT and %qT",
5020      --The second and third operands have the same type; the result  is  of
5026      --The second and third operands have arithmetic or enumeration
5049 	    /* Two enumerators from the same enumeration can have different
5073      --The second and third operands have pointer type, or one has
5080      --The second and third operands have pointer to member type, or
5107         error_at (loc, "operands to ?: have different types %qT and %qT",
5121   /* We can't use result_type below, as fold might have returned a
5447      only non-member functions that have type T1 or reference to
5878 	 deallocation function, would have been selected as a match for the
5960   /* If we have a matching function, call it.  */
6662       /* In a template (or ill-formed code), we can have an incomplete type
6742    would have happened when passed via ellipsis.  Return the promoted
6863      to TYPE -- it cannot have a precision greater than TYPE.
6871      often have type "int", even though the C++ type for the field is
7146 	 primary template because `B<T>::g' and `B<int>::g' may have
7301          For example, if we have this template function:
7450       /* If we're creating a temp and we already have one, don't create a
8276 		   will appear to have a return value of pointer type
8510      what would have happened if they'd been good.  This is not an
8532      ranked as a user-defined conversion and it doesn't have a second
8533      standard conversion sequence; it will still have the desired effect.
8630     so that we do not have to check it explicitly.  */
8923   /* If we have two pseudo-candidates for conversions to the same type,
9125 	    templates.   add_function_candidate() will not have
9133      have two identical ones or matching builtin and non-builtin candidates.
9140      - do not have the same parameter type list as any non-template
9468 	 type of non-dependent expressions, so we do not have to