Lines Matching defs:Conversion
104 /// GetConversionCategory - Retrieve the implicit conversion
105 /// category corresponding to the given implicit conversion kind.
136 /// GetConversionRank - Retrieve the implicit conversion rank
137 /// corresponding to the given implicit conversion kind.
170 /// implicit conversion.
173 "No conversion",
182 "Integral conversion",
183 "Floating conversion",
184 "Complex conversion",
185 "Floating-integral conversion",
186 "Pointer conversion",
187 "Pointer-to-member conversion",
188 "Boolean conversion",
189 "Compatible-types conversion",
190 "Derived-to-base conversion",
191 "Vector conversion",
193 "Complex-real conversion",
194 "Block Pointer conversion",
195 "Transparent Union Conversion"
196 "Writeback conversion"
201 /// StandardConversionSequence - Set the standard conversion
202 /// sequence to the identity conversion.
219 /// getRank - Retrieve the rank of this standard conversion sequence
233 /// isPointerConversionToBool - Determines whether this conversion is
234 /// a conversion of a pointer or pointer-to-member to bool. This is
235 /// used as part of the ranking of standard conversion sequences
254 /// conversion is a conversion of a pointer to a void pointer. This is
255 /// used as part of the ranking of standard conversion sequences (C++
264 // array-to-pointer implicit conversion, so check for its presence
265 // and redo the conversion to get a pointer.
276 /// Skip any implicit casts which could be either part of a narrowing conversion
277 /// or after one in an implicit conversion.
299 /// Check if this standard conversion sequence represents a narrowing
300 /// conversion, according to C++11 [dcl.init.list]p7.
303 /// \param Converted The result of applying this standard conversion sequence.
304 /// \param ConstantValue If this is an NK_Constant_Narrowing conversion, the
305 /// value of the expression prior to the narrowing conversion.
306 /// \param ConstantType If this is an NK_Constant_Narrowing conversion, the
307 /// type of the expression prior to the narrowing conversion.
316 // A narrowing conversion is an implicit conversion ...
324 // value after conversion will fit into the target type and will produce
343 // If the resulting value is different, this was a narrowing conversion.
358 // conversion is within the range of values that can be represented (even
389 // conversion will fit into the target type and will produce the original
432 // If the result is different, this was a narrowing conversion.
451 /// DebugPrint - Print this standard conversion sequence to standard
490 /// DebugPrint - Print this user-defined conversion sequence to standard
508 /// DebugPrint - Print this implicit conversion sequence to standard
514 OS << "Standard conversion: ";
518 OS << "User-defined conversion: ";
522 OS << "Ellipsis conversion";
525 OS << "Ambiguous conversion";
528 OS << "Bad conversion";
1088 /// \brief Tries a user-defined conversion from From to ToType.
1090 /// Produces an implicit conversion sequence for when a standard conversion
1102 // We're not in the case above, so there is no conversion that
1108 // Attempt user-defined conversion.
1117 // A conversion of an expression of class type to the same class
1118 // type is given Exact Match rank, and a conversion of an
1120 // given Conversion rank, in spite of the fact that a copy
1121 // constructor (i.e., a user-defined conversion function) is
1131 // Turn this into a "standard" conversion sequence, so that it
1132 // gets ranked with standard conversion sequences.
1145 // conversion function that is a candidate by 13.3.1.3 when
1148 // 13.3.1.6 in all cases, only standard conversion sequences and
1149 // ellipsis conversion sequences are allowed.
1168 /// TryImplicitConversion - Attempt to perform an implicit conversion
1170 /// function returns an implicit conversion sequence that can be used
1176 /// this routine would produce an implicit conversion sequence to
1178 /// conversion sequence containing an lvalue-to-rvalue conversion (C++
1179 /// 4.1) followed by a floating-integral conversion (C++ 4.9).
1181 /// Note that this routine only determines how the conversion can be
1182 /// performed; it does not actually perform the conversion. As such,
1183 /// it will not produce any diagnostics if no conversion is available,
1184 /// but will instead return an implicit conversion sequence of kind
1193 /// writeback conversion, which allows __autoreleasing id* parameters to
1215 // A conversion of an expression of class type to the same class
1216 // type is given Exact Match rank, and a conversion of an
1218 // given Conversion rank, in spite of the fact that a copy/move
1219 // constructor (i.e., a user-defined conversion function) is
1236 // Determine whether this is considered a derived-to-base conversion.
1261 /// PerformImplicitConversion - Perform an implicit conversion of the
1263 /// converted expression. Flavor is the kind of conversion we're
1280 // Objective-C ARC: Determine whether we will allow the writeback conversion.
1294 /// \brief Determine whether the conversion from FromType to ToType is a valid
1295 /// conversion that strips "noreturn" off the nested function type.
1301 // Permit the conversion F(t __attribute__((noreturn))) -> F(t)
1342 /// \brief Determine whether the conversion from FromType to ToType is a valid
1343 /// vector conversion.
1345 /// \param ICK Will be set to the vector conversion kind, if this is a vector
1346 /// conversion.
1350 // conversion.
1361 // identity conversion.
1372 // We can perform the conversion between vector types in the following cases:
1394 /// conversion sequence (C++ [conv], C++ [over.ics.scs]) from the
1395 /// expression From to the type ToType. Standard conversion sequences
1397 /// types, use TryImplicitConversion. If a conversion exists, SCS will
1398 /// contain the standard conversion sequence required to perform this
1399 /// conversion and this routine will return true. Otherwise, this
1424 // The first conversion can be an lvalue-to-rvalue conversion,
1425 // array-to-pointer conversion, or function-to-pointer conversion
1445 // otherwise, only a boolean conversion is standard
1479 // Lvalue-to-rvalue conversion (C++11 4.1):
1500 // Array-to-pointer conversion (C++ 4.2)
1509 // This conversion is deprecated. (C++ D.4).
1513 // (13.3.3.1.1), this conversion is considered an
1514 // array-to-pointer conversion followed by a qualification
1515 // conversion (4.4). (C++ 4.2p2)
1523 // Function-to-pointer conversion (C++ 4.3).
1536 // The second conversion can be an integral promotion, floating
1537 // point promotion, integral conversion, floating point conversion,
1538 // floating-integral conversion, pointer conversion,
1539 // pointer-to-member conversion, or boolean conversion (C++ 4p1).
1541 // conversion.
1546 // conversion to do.
1618 // Treat a conversion that strips "noreturn" as an identity conversion.
1627 // tryAtomicConversion has updated the standard conversion sequence
1636 // No second conversion required.
1643 // The third conversion can be a qualification conversion (C++ 4p1).
1653 // No conversion required
1659 // a conversion. [...]
1672 // this is a bad conversion sequence.
1704 /// IsIntegralPromotion - Determines whether the conversion from the
1743 // with lowest integer conversion rank (4.13) greater than the rank of long
1753 // C++0x 7.2p9: Note that this implicit enum to int conversion is not
1817 // conversion.
1852 /// IsFloatingPointPromotion - Determines whether the conversion from
1883 /// \brief Determine if a conversion is a complex promotion.
1885 /// A complex promotion is defined as a complex -> complex conversion
1886 /// where the conversion between the underlying real types is a
1903 /// BuildSimilarlyQualifiedPointerType - In a pointer conversion from
1966 /// IsPointerConversion - Determines whether the conversion of the
1968 /// can be converted to the type ToType via a pointer conversion (C++
1980 /// set if the conversion is an allowed Objective-C conversion that
1991 // Conversion from a null pointer constant to any Objective-C pointer type.
2048 // pointer conversion, so don't do all of the work below.
2064 // MSVC allows implicit function to void* type conversion.
2074 // conversion for compatible-but-not-identical pointee types.
2089 // necessitates this conversion is ill-formed. The result of the
2090 // conversion is a pointer to the base class sub-object of the
2133 /// Objective-C pointer conversion. Subroutine of IsPointerConversion,
2152 // then this is not a pointer conversion.
2234 // is an Objective-C conversion.
2238 // We always complain about this conversion.
2244 // Allow conversion of pointee being objective-c pointer to another one;
2258 // pointer conversions. If so, we permit the conversion (but
2266 // Objective-C pointer conversion.
2285 // Okay, we have an Objective-C pointer conversion.
2302 // Okay, we have an Objective-C pointer conversion.
2311 // We had an Objective-C conversion. Allow this pointer
2312 // conversion, but complain about it.
2322 /// \brief Determine whether this is an Objective-C writeback conversion,
2330 /// this conversion.
2406 // pointer conversions. If so, we permit the conversion.
2447 // Okay, we have an Objective-C pointer conversion.
2465 // Okay, we have an Objective-C pointer conversion.
2595 /// CheckPointerConversion - Check the pointer conversion from the
2628 // We must have a derived-to-base conversion. Check an
2629 // ambiguous or inaccessible conversion.
2636 // The conversion was successful.
2667 /// IsMemberPointerConversion - Determines whether the conversion of the
2669 /// converted to the type ToType via a member pointer conversion (C++ 4.11).
2709 /// CheckMemberPointerConversion - Check the member pointer conversion from the
2722 // This must be a null pointer to member pointer conversion
2768 // Must be a base to derived member conversion.
2774 /// IsQualificationConversion - Determines whether the conversion from
2775 /// an rvalue of type FromType to ToType is a qualification conversion
2779 /// when the qualification conversion involves a change in the Objective-C
2789 // qualification conversion.
2794 // A conversion can add cv-qualifiers at levels other than the first
2801 // conversion. Then, if all is well, we unwrap one more level of
2853 // qualifiers above), then this is a qualification conversion.
2857 /// \brief - Determine whether this is a conversion from a scalar type to an
2860 /// If successful, updates \c SCS's second and third steps in the conversion
2861 /// sequence to finish the conversion.
2945 // Record the standard conversion we used and the conversion function.
2970 /// Determines whether there is a user-defined conversion sequence
2972 /// ToType. If such a conversion exists, User will contain the
2973 /// user-defined conversion sequence that performs such a conversion
2977 /// \param AllowExplicit true if the conversion should consider C++0x
2978 /// "explicit" conversion functions as well as non-explicit conversion
2988 // If the type we are conversion to is a class type, enumerate its
3070 // Allow one user-defined conversion when user specifies a
3071 // From->ToType conversion via an static cast (c-style, etc).
3080 // Enumerate conversion functions, if we're allowed to.
3083 // No conversion functions from incomplete types.
3088 // Add all of the conversion functions as candidates.
3125 // Record the standard conversion we used and the conversion function.
3129 // If the user-defined conversion is specified by a
3130 // constructor (12.3.1), the initial standard conversion
3154 if (CXXConversionDecl *Conversion
3158 // [...] If the user-defined conversion is specified by a
3159 // conversion function (12.3.2), the initial standard
3160 // conversion sequence converts the source type to the
3161 // implicit object parameter of the conversion function.
3164 User.ConversionFunction = Conversion;
3169 // The second standard conversion sequence converts the
3170 // result of the user-defined conversion to the target type
3171 // for the sequence. Since an implicit conversion sequence
3173 // initialization by user-defined conversion apply when
3174 // selecting the best user-defined conversion for a
3175 // user-defined conversion sequence (see 13.3.3 and
3180 llvm_unreachable("Not a constructor or conversion function?");
3185 // No conversion here! We're done.
3220 /// \brief Compare the user-defined conversion functions or constructors
3221 /// of two user-defined conversion sequences to determine whether any ordering
3231 // If both conversion functions are implicitly-declared conversions from
3233 // respectively, always prefer the conversion to a function pointer,
3256 /// conversion sequences to determine whether one is better than the
3264 // conversion sequences (as defined in 13.3.3.1)
3265 // -- a standard conversion sequence (13.3.3.1.1) is a better
3266 // conversion sequence than a user-defined conversion sequence or
3267 // an ellipsis conversion sequence, and
3268 // -- a user-defined conversion sequence (13.3.3.1.2) is a better
3269 // conversionconversion sequence
3273 // For the purpose of ranking implicit conversion sequences as
3274 // described in 13.3.3.2, the ambiguous conversion sequence is
3276 // from any other user-defined conversion sequence.
3282 // The following checks require both conversion sequences to be of
3290 // Two implicit conversion sequences of the same form are
3291 // indistinguishable conversion sequences unless one of the
3297 // User-defined conversion sequence U1 is a better conversion
3298 // sequence than another user-defined conversion sequence U2 if
3299 // they contain the same user-defined conversion function or
3300 // constructor and if the second standard conversion sequence of
3301 // U1 is better than the second standard conversion sequence of
3314 // List-initialization sequence L1 is a better conversion sequence than
3342 // Per 13.3.3.2p3, compare the given standard conversion sequences to
3351 // the identity conversion sequence is considered to be a subsequence of
3352 // any non-identity conversion sequence
3414 /// conversion sequences to determine whether one is better than the
3421 // Standard conversion sequence S1 is a better conversion sequence
3422 // than standard conversion sequence S2 if (C++ 13.3.3.2p3):
3424 // -- S1 is a proper subsequence of S2 (comparing the conversion
3426 // excluding any Lvalue Transformation; the identity conversion
3428 // non-identity conversion sequence) or, if not that,
3442 // (C++ 13.3.3.2p4): Two conversion sequences with the same rank
3446 // A conversion that is not a conversion of a pointer, or
3447 // pointer to member, to bool is better than another conversion
3448 // that is such a conversion.
3457 // conversion of B* to A* is better than conversion of B* to
3458 // void*, and conversion of A* to void* is better than conversion
3465 // Exactly one of the conversion sequences is a conversion to
3466 // a void pointer; it's the worse conversion.
3470 // Neither conversion sequence converts to a void pointer; compare
3477 // Both conversion sequences are conversions to void
3484 // conversion, if we need to.
3565 // In Microsoft mode, prefer an integral conversion to a
3566 // floating-to-integral conversion if the integral conversion
3587 /// CompareQualificationConversions - Compares two standard conversion
3595 // -- S1 and S2 differ only in their qualification conversion and
3599 // deprecated string literal array-to-pointer conversion (4.2).
3605 // conversion (!)
3642 // conversion. Then, if all is well, we unwrap one more level of
3678 // Check that the winning standard conversion sequence isn't using
3679 // the deprecated string literal array to pointer conversion.
3698 /// CompareDerivedToBaseConversions - Compares two standard conversion
3713 // conversion, if we need to.
3745 // -- conversion of C* to B* is better than conversion of C* to A*,
3753 // -- conversion of B* to A* is better than conversion of C* to A*,
3772 // Apply the same conversion ranking rules for Objective-C pointer types
3785 // A conversion to an a non-id object pointer type or qualified 'id'
3786 // type is better than a conversion to 'id'.
3794 // A conversion to a non-id object pointer type is better than a
3795 // conversion to a qualified 'id' type
3801 // A conversion to an a non-Class object pointer type or qualified 'Class'
3802 // type is better than a conversion to 'Class'.
3810 // A conversion to a non-Class object pointer type is better than a
3811 // conversion to a qualified 'Class' type.
3817 // -- "conversion of C* to B* is better than conversion of C* to A*,"
3824 // -- "conversion of B* to A* is better than conversion of C* to A*,"
3852 // conversion of A::* to B::* is better than conversion of A::* to C::*,
3859 // conversion of B::* to C::* is better than conversion of A::* to C::*
3869 // -- conversion of C to B is better than conversion of C to A,
3881 // -- conversion of B to A is better than conversion of C to A.
3986 /// \brief Look for a user-defined conversion to an value reference-compatible
4016 // If this is an explicit conversion, and we're not allowed to consider
4026 // If we are initializing an rvalue reference, don't permit conversion
4045 // If the conversion function doesn't return a reference type,
4046 // it can't be considered for this conversion. An rvalue reference
4073 // applying a conversion function to the argument
4074 // expression, the implicit conversion sequence is a
4075 // user-defined conversion sequence (13.3.3.1.2), with the
4076 // second standard conversion sequence either an identity
4077 // conversion or, if the conversion function returns an
4079 // type, a derived-to-base Conversion.
4105 // There was no suitable conversion, or we found a deleted
4106 // conversion; continue with other checks.
4113 /// \brief Compute an implicit conversion sequence for reference
4122 // Most paths end in a failed conversion.
4164 // to an argument expression, the implicit conversion sequence
4165 // is the identity conversion, unless the argument expression
4167 // in which case the implicit conversion sequence is a
4168 // derived-to-base Conversion (13.3.3.1).
4190 // computing the implicit conversion sequence (C++
4199 // conversion is selected by enumerating the applicable
4200 // conversion functions (13.3.1.6) and choosing the best
4218 // binding by only attempting a simple conversion for non-direct
4271 // expression in the first case and to the result of the conversion
4280 // and the second standard conversion sequence of the
4281 // user-defined conversion sequence includes an lvalue-to-rvalue
4282 // conversion, the program is ill-formed.
4332 // an argument expression, the conversion sequence is the one
4335 // 13.3.3.1. Conceptually, this conversion sequence corresponds
4339 // and does not constitute a conversion.
4409 // conversion sequence is the worst conversion necessary to convert an
4429 // Otherwise, look for the worst conversion.
4436 // For an empty list, we won't have computed any conversion sequence.
4437 // Introduce the identity conversion sequence.
4453 // conversion sequence is a user-defined conversion sequence. If multiple
4455 // implicit conversion sequence is a user-defined conversion sequence.
4468 // initialized from the initializer list [...] the implicit conversion
4469 // sequence is a user-defined conversion sequence.
4541 "Sub-initialization cannot result in ellipsis conversion.");
4563 // - if the initializer list has one element, the implicit conversion
4572 // - if the initializer list has no elements, the implicit conversion
4573 // sequence is the identity conversion.
4585 // In all cases other than those enumerated above, no conversion is possible
4590 /// ToType from the expression From. Return the implicit conversion
4592 /// conversion sequence (meaning that the argument cannot be passed to
4594 /// do not permit any user-defined conversion sequences.
4646 // Set up the conversion sequence as a "bad" conversion, to allow us
4673 // However, when finding an implicit conversion sequence for the argument, we
4690 // affects the conversion rank.
4821 /// PerformContextuallyConvertToBool - Perform a contextual conversion
4838 /// Check that the specified conversion is permitted in a converted constant
4839 /// expression, according to C++11 [expr.const]p3. Return true if the conversion
4844 // type, most conversion kinds are impossible. All possible First and Third
4854 // Conversion from an integral or unscoped enumeration type to bool is
4856 // conversion, so it's permitted in a converted constant expression.
4882 llvm_unreachable("unexpected second conversion kind");
4888 llvm_unreachable("unknown conversion kind");
4892 /// converted constant expression of type T, perform the conversion and produce
4906 // expression is a literal constant expression and the implicit conversion
4944 llvm_unreachable("ellipsis conversion in converted constant expression");
4951 // Check for a narrowing implicit conversion.
4957 // Implicit conversion to a narrower type, and the value is not a constant
5009 /// dropPointerConversions - If the given standard conversion sequence
5011 /// the result type of the conversion sequence.
5024 // Do an implicit conversion to 'id'.
5055 /// conversion of the expression From to an Objective-C pointer type.
5100 CXXConversionDecl *Conversion =
5104 // conversion; use it.
5105 QualType ConvTy = Conversion->getConversionType().getNonReferenceType();
5114 Converter.noteExplicitConv(SemaRef, Conversion, ConvTy);
5117 // explicit conversion function.
5122 ExprResult Result = SemaRef.BuildCXXMemberCallExpr(From, Found, Conversion,
5126 // Record usage of conversion in an implicit cast.
5138 CXXConversionDecl *Conversion =
5142 QualType ToType = Conversion->getConversionType().getNonReferenceType();
5151 ExprResult Result = SemaRef.BuildCXXMemberCallExpr(From, Found, Conversion,
5155 // Record usage of conversion in an implicit cast.
5204 /// must have a single non-explicit conversion function converting to a matching
5205 /// type. In C++1y, there can be multiple such conversion functions, but only
5209 /// conversion.
5213 /// \param Converter Used to control and diagnose the conversion process.
5263 // Look for a conversion to an integral or enumeration type.
5283 CXXConversionDecl *Conversion;
5287 Conversion = cast<CXXConversionDecl>(ConvTemplate->getTemplatedDecl());
5289 continue; // C++11 does not consider conversion operator templates(?).
5291 Conversion = cast<CXXConversionDecl>(D);
5294 "Conversion operator templates are considered potentially "
5297 QualType CurToType = Conversion->getConversionType().getNonReferenceType();
5300 if (Conversion->isExplicit()) {
5324 // for conversion functions whose return type is cv T or reference to
5353 // Apply this conversion.
5386 // Apply this conversion.
5405 /// conversions via constructors or conversion operators.
5503 // Determine the implicit conversion sequences for each of the
5508 // exist for each argument an implicit conversion sequence
5605 /// allow user-defined conversions via constructors or conversion
5664 // Determine the implicit conversion sequence for the object
5676 // Determine the implicit conversion sequences for each of the
5681 // exist for each argument an implicit conversion sequence
5805 /// AddConversionCandidate - Add a C++ conversion function as a
5810 /// conversion function produces).
5812 Sema::AddConversionCandidate(CXXConversionDecl *Conversion,
5817 assert(!Conversion->getDescribedFunctionTemplate() &&
5818 "Conversion function templates use AddTemplateConversionCandidate");
5819 QualType ConvType = Conversion->getConversionType().getNonReferenceType();
5820 if (!CandidateSet.isNewCandidate(Conversion))
5823 // If the conversion function has an undeduced return type, trigger its
5826 if (DeduceReturnType(Conversion, From->getExprLoc()))
5828 ConvType = Conversion->getConversionType().getNonReferenceType();
5837 Candidate.Function = Conversion;
5847 // For conversion functions, the function is considered to be a member of
5851 // Determine the implicit conversion sequence for the implicit
5862 Conversion, ConversionContext);
5870 // We won't go through a user-define type conversion function to convert a
5871 // derived to base as such conversions are given Conversion Rank. They only
5882 // To determine what the conversion from the result of calling the
5883 // conversion function to the type we're eventually trying to
5885 // conversion function and attempt copy initialization from it. This
5890 DeclRefExpr ConversionRef(Conversion, false, Conversion->getType(),
5893 Context.getPointerType(Conversion->getType()),
5897 QualType ConversionType = Conversion->getConversionType();
5923 // If the user-defined conversion is specified by a specialization of a
5924 // conversion function template, the second standard conversion sequence
5926 if (Conversion->getPrimaryTemplate() &&
5934 // the second standard conversion sequence of the user-defined
5935 // conversion sequence includes an lvalue-to-rvalue conversion, the
5951 "Can only end up with a standard conversion sequence or failure");
5955 /// \brief Adds a conversion function template specialization
5957 /// to deduce the template arguments of the conversion function
5967 "Only conversion function templates permitted here");
5990 // Add the conversion function template specialization produced by
5999 /// conversion function @c Conversion, and then attempts to call it
6002 void Sema::AddSurrogateCandidate(CXXConversionDecl *Conversion,
6009 if (!CandidateSet.isNewCandidate(Conversion))
6018 Candidate.Surrogate = Conversion;
6024 // Determine the implicit conversion sequence for the implicit
6029 Conversion, ActingContext);
6037 // The first conversion is actually a user-defined conversion whose
6038 // first conversion is ObjectInit's standard conversion (which is
6044 Candidate.Conversions[0].UserDefined.ConversionFunction = Conversion;
6071 // Determine the implicit conversion sequences for each of the
6076 // exist for each argument an implicit conversion sequence
6178 // Determine the implicit conversion sequences for each of the
6197 "Contextual conversion to bool requires bool type");
6424 /// AllowUserConversions is true if we should look at the conversion
6426 /// should also include the explicit conversion functions of a class
6479 // No conversion functions in incomplete types.
6493 // Skip conversion function templates; they don't tell us anything
6533 /// if any, found in visible type conversion functions found in ArgExpr's type.
7924 // conversion sequence than ICSi(F2), and then...
7933 // Cand1 has a better conversion sequence.
7947 // -- for some argument j, ICSj(F1) is a better conversion sequence than
7974 // -- the context is an initialization by user-defined conversion
7975 // (see 8.5, 13.3.1.5) and the standard conversion sequence
7978 // conversion sequence than the standard conversion sequence
7983 // First check whether we prefer one of the conversion functions over the
7985 // cases such as the conversion from a lambda closure type to a function
7996 // Cand1 has a better conversion sequence.
8118 assert(isa<CXXConversionDecl>(Meth) && "expected conversion");
8169 /// Diagnoses an ambiguous conversion. The partial diagnostic is the
8171 /// target types of the conversion.
8202 // There's a conversion slot for the object argument if this is a
8204 // conversion-slot index.
8402 // If we can fix the conversion, suggest the FixIts.
8769 // when user-conversion overload fails. Figure out how to handle
8924 // The conversion that can be fixed with a smaller number of changes,
8996 // Don't do anything on failures other than bad conversion.
9001 // Use a implicit copy initialization to check conversion fixes.
9004 // Skip forward to the first bad conversion.
9008 assert(ConvIdx != ConvCount && "no bad conversion in candidate");
9020 "remaining conversion is initialized?");
9042 // Builtin binary operator with a bad first conversion.
9128 // ambiguous user-defined conversion.
10549 // Do placeholder-like conversion on the LHS; note that we should
11186 /// user-defined conversion on the object argument.
11230 // In addition, for each (non-explicit in C++0x) conversion function
11233 // operator conversion-type-id () cv-qualifier;
11236 // greater cv-qualification than, cv, and where conversion-type-id
11243 // functions for each conversion function declared in an
11256 // Skip over templated conversion functions; they aren't
11325 // surrogate candidates. Dig out the conversion function.
11334 "Found Decl & conversion-to-functionptr should be same, right?!");
11336 // object parameter to a function pointer. Perform the conversion
11339 // Create an implicit member expr to refer to the conversion operator.
11345 // Record usage of conversion in an implicit cast.
11764 assert(ICE->path_empty() && "fixing up hierarchy conversion?");
