Lines Matching full:conversion
89 /// GetConversionCategory - Retrieve the implicit conversion
90 /// category corresponding to the given implicit conversion kind.
121 /// GetConversionRank - Retrieve the implicit conversion rank
122 /// corresponding to the given implicit conversion kind.
155 /// implicit conversion.
158 "No conversion",
167 "Integral conversion",
168 "Floating conversion",
169 "Complex conversion",
170 "Floating-integral conversion",
171 "Pointer conversion",
172 "Pointer-to-member conversion",
173 "Boolean conversion",
174 "Compatible-types conversion",
175 "Derived-to-base conversion",
176 "Vector conversion",
178 "Complex-real conversion",
179 "Block Pointer conversion",
180 "Transparent Union Conversion"
181 "Writeback conversion"
186 /// StandardConversionSequence - Set the standard conversion
187 /// sequence to the identity conversion.
204 /// getRank - Retrieve the rank of this standard conversion sequence
218 /// isPointerConversionToBool - Determines whether this conversion is
219 /// a conversion of a pointer or pointer-to-member to bool. This is
220 /// used as part of the ranking of standard conversion sequences
239 /// conversion is a conversion of a pointer to a void pointer. This is
240 /// used as part of the ranking of standard conversion sequences (C++
249 // array-to-pointer implicit conversion, so check for its presence
250 // and redo the conversion to get a pointer.
261 /// Skip any implicit casts which could be either part of a narrowing conversion
262 /// or after one in an implicit conversion.
284 /// Check if this standard conversion sequence represents a narrowing
285 /// conversion, according to C++11 [dcl.init.list]p7.
288 /// \param Converted The result of applying this standard conversion sequence.
289 /// \param ConstantValue If this is an NK_Constant_Narrowing conversion, the
290 /// value of the expression prior to the narrowing conversion.
291 /// \param ConstantType If this is an NK_Constant_Narrowing conversion, the
292 /// type of the expression prior to the narrowing conversion.
301 // A narrowing conversion is an implicit conversion ...
309 // value after conversion will fit into the target type and will produce
328 // If the resulting value is different, this was a narrowing conversion.
343 // conversion is within the range of values that can be represented (even
374 // conversion will fit into the target type and will produce the original
408 // If the result is different, this was a narrowing conversion.
427 /// DebugPrint - Print this standard conversion sequence to standard
466 /// DebugPrint - Print this user-defined conversion sequence to standard
484 /// DebugPrint - Print this implicit conversion sequence to standard
490 OS << "Standard conversion: ";
494 OS << "User-defined conversion: ";
498 OS << "Ellipsis conversion";
501 OS << "Ambiguous conversion";
504 OS << "Bad conversion";
997 /// \brief Tries a user-defined conversion from From to ToType.
999 /// Produces an implicit conversion sequence for when a standard conversion
1011 // We're not in the case above, so there is no conversion that
1017 // Attempt user-defined conversion.
1026 // A conversion of an expression of class type to the same class
1027 // type is given Exact Match rank, and a conversion of an
1029 // given Conversion rank, in spite of the fact that a copy
1030 // constructor (i.e., a user-defined conversion function) is
1040 // Turn this into a "standard" conversion sequence, so that it
1041 // gets ranked with standard conversion sequences.
1054 // conversion function that is a candidate by 13.3.1.3 when
1057 // 13.3.1.6 in all cases, only standard conversion sequences and
1058 // ellipsis conversion sequences are allowed.
1077 /// TryImplicitConversion - Attempt to perform an implicit conversion
1079 /// function returns an implicit conversion sequence that can be used
1085 /// this routine would produce an implicit conversion sequence to
1087 /// conversion sequence containing an lvalue-to-rvalue conversion (C++
1088 /// 4.1) followed by a floating-integral conversion (C++ 4.9).
1090 /// Note that this routine only determines how the conversion can be
1091 /// performed; it does not actually perform the conversion. As such,
1092 /// it will not produce any diagnostics if no conversion is available,
1093 /// but will instead return an implicit conversion sequence of kind
1102 /// writeback conversion, which allows __autoreleasing id* parameters to
1124 // A conversion of an expression of class type to the same class
1125 // type is given Exact Match rank, and a conversion of an
1127 // given Conversion rank, in spite of the fact that a copy/move
1128 // constructor (i.e., a user-defined conversion function) is
1145 // Determine whether this is considered a derived-to-base conversion.
1170 /// PerformImplicitConversion - Perform an implicit conversion of the
1172 /// converted expression. Flavor is the kind of conversion we're
1189 // Objective-C ARC: Determine whether we will allow the writeback conversion.
1203 /// \brief Determine whether the conversion from FromType to ToType is a valid
1204 /// conversion that strips "noreturn" off the nested function type.
1210 // Permit the conversion F(t __attribute__((noreturn))) -> F(t)
1251 /// \brief Determine whether the conversion from FromType to ToType is a valid
1252 /// vector conversion.
1254 /// \param ICK Will be set to the vector conversion kind, if this is a vector
1255 /// conversion.
1259 // conversion.
1270 // identity conversion.
1281 // We can perform the conversion between vector types in the following cases:
1303 /// conversion sequence (C++ [conv], C++ [over.ics.scs]) from the
1304 /// expression From to the type ToType. Standard conversion sequences
1306 /// types, use TryImplicitConversion. If a conversion exists, SCS will
1307 /// contain the standard conversion sequence required to perform this
1308 /// conversion and this routine will return true. Otherwise, this
1333 // The first conversion can be an lvalue-to-rvalue conversion,
1334 // array-to-pointer conversion, or function-to-pointer conversion
1354 // otherwise, only a boolean conversion is standard
1388 // Lvalue-to-rvalue conversion (C++11 4.1):
1409 // Array-to-pointer conversion (C++ 4.2)
1418 // This conversion is deprecated. (C++ D.4).
1422 // (13.3.3.1.1), this conversion is considered an
1423 // array-to-pointer conversion followed by a qualification
1424 // conversion (4.4). (C++ 4.2p2)
1432 // Function-to-pointer conversion (C++ 4.3).
1445 // The second conversion can be an integral promotion, floating
1446 // point promotion, integral conversion, floating point conversion,
1447 // floating-integral conversion, pointer conversion,
1448 // pointer-to-member conversion, or boolean conversion (C++ 4p1).
1450 // conversion.
1455 // conversion to do.
1527 // Treat a conversion that strips "noreturn" as an identity conversion.
1536 // tryAtomicConversion has updated the standard conversion sequence
1540 // No second conversion required.
1547 // The third conversion can be a qualification conversion (C++ 4p1).
1557 // No conversion required
1563 // a conversion. [...]
1578 // this is a bad conversion sequence.
1610 /// IsIntegralPromotion - Determines whether the conversion from the
1649 // with lowest integer conversion rank (4.13) greater than the rank of long
1653 // C++0x 7.2p9: Note that this implicit enum to int conversion is not
1709 // conversion.
1744 /// IsFloatingPointPromotion - Determines whether the conversion from
1774 /// \brief Determine if a conversion is a complex promotion.
1776 /// A complex promotion is defined as a complex -> complex conversion
1777 /// where the conversion between the underlying real types is a
1794 /// BuildSimilarlyQualifiedPointerType - In a pointer conversion from
1857 /// IsPointerConversion - Determines whether the conversion of the
1859 /// can be converted to the type ToType via a pointer conversion (C++
1871 /// set if the conversion is an allowed Objective-C conversion that
1882 // Conversion from a null pointer constant to any Objective-C pointer type.
1939 // pointer conversion, so don't do all of the work below.
1955 // MSVC allows implicit function to void* type conversion.
1965 // conversion for compatible-but-not-identical pointee types.
1980 // necessitates this conversion is ill-formed. The result of the
1981 // conversion is a pointer to the base class sub-object of the
2024 /// Objective-C pointer conversion. Subroutine of IsPointerConversion,
2043 // then this is not a pointer conversion.
2125 // is an Objective-C conversion.
2129 // We always complain about this conversion.
2135 // Allow conversion of pointee being objective-c pointer to another one;
2149 // pointer conversions. If so, we permit the conversion (but
2157 // Objective-C pointer conversion.
2176 // Okay, we have an Objective-C pointer conversion.
2193 // Okay, we have an Objective-C pointer conversion.
2202 // We had an Objective-C conversion. Allow this pointer
2203 // conversion, but complain about it.
2213 /// \brief Determine whether this is an Objective-C writeback conversion,
2221 /// this conversion.
2297 // pointer conversions. If so, we permit the conversion.
2338 // Okay, we have an Objective-C pointer conversion.
2356 // Okay, we have an Objective-C pointer conversion.
2519 /// CheckPointerConversion - Check the pointer conversion from the
2548 // We must have a derived-to-base conversion. Check an
2549 // ambiguous or inaccessible conversion.
2556 // The conversion was successful.
2587 /// IsMemberPointerConversion - Determines whether the conversion of the
2589 /// converted to the type ToType via a member pointer conversion (C++ 4.11).
2629 /// CheckMemberPointerConversion - Check the member pointer conversion from the
2642 // This must be a null pointer to member pointer conversion
2688 // Must be a base to derived member conversion.
2694 /// IsQualificationConversion - Determines whether the conversion from
2695 /// an rvalue of type FromType to ToType is a qualification conversion
2699 /// when the qualification conversion involves a change in the Objective-C
2709 // qualification conversion.
2714 // A conversion can add cv-qualifiers at levels other than the first
2721 // conversion. Then, if all is well, we unwrap one more level of
2773 // qualifiers above), then this is a qualification conversion.
2777 /// \brief - Determine whether this is a conversion from a scalar type to an
2780 /// If successful, updates \c SCS's second and third steps in the conversion
2781 /// sequence to finish the conversion.
2865 // Record the standard conversion we used and the conversion function.
2892 /// Determines whether there is a user-defined conversion sequence
2894 /// ToType. If such a conversion exists, User will contain the
2895 /// user-defined conversion sequence that performs such a conversion
2899 /// \param AllowExplicit true if the conversion should consider C++0x
2900 /// "explicit" conversion functions as well as non-explicit conversion
2910 // If the type we are conversion to is a class type, enumerate its
2992 // Allow one user-defined conversion when user specifies a
2993 // From->ToType conversion via an static cast (c-style, etc).
3002 // Enumerate conversion functions, if we're allowed to.
3006 // No conversion functions from incomplete types.
3011 // Add all of the conversion functions as candidates.
3047 // Record the standard conversion we used and the conversion function.
3053 // If the user-defined conversion is specified by a
3054 // constructor (12.3.1), the initial standard conversion
3078 if (CXXConversionDecl *Conversion
3080 S.MarkFunctionReferenced(From->getLocStart(), Conversion);
3084 // [...] If the user-defined conversion is specified by a
3085 // conversion function (12.3.2), the initial standard
3086 // conversion sequence converts the source type to the
3087 // implicit object parameter of the conversion function.
3090 User.ConversionFunction = Conversion;
3095 // The second standard conversion sequence converts the
3096 // result of the user-defined conversion to the target type
3097 // for the sequence. Since an implicit conversion sequence
3099 // initialization by user-defined conversion apply when
3100 // selecting the best user-defined conversion for a
3101 // user-defined conversion sequence (see 13.3.3 and
3106 llvm_unreachable("Not a constructor or conversion function?");
3111 // No conversion here! We're done.
3142 /// \brief Compare the user-defined conversion functions or constructors
3143 /// of two user-defined conversion sequences to determine whether any ordering
3153 // If both conversion functions are implicitly-declared conversions from
3155 // respectively, always prefer the conversion to a function pointer,
3178 /// conversion sequences to determine whether one is better than the
3186 // conversion sequences (as defined in 13.3.3.1)
3187 // -- a standard conversion sequence (13.3.3.1.1) is a better
3188 // conversion sequence than a user-defined conversion sequence or
3189 // an ellipsis conversion sequence, and
3190 // -- a user-defined conversion sequence (13.3.3.1.2) is a better
3191 // conversion sequence than an ellipsis conversion sequence
3195 // For the purpose of ranking implicit conversion sequences as
3196 // described in 13.3.3.2, the ambiguous conversion sequence is
3198 // from any other user-defined conversion sequence.
3204 // The following checks require both conversion sequences to be of
3212 // Two implicit conversion sequences of the same form are
3213 // indistinguishable conversion sequences unless one of the
3219 // User-defined conversion sequence U1 is a better conversion
3220 // sequence than another user-defined conversion sequence U2 if
3221 // they contain the same user-defined conversion function or
3222 // constructor and if the second standard conversion sequence of
3223 // U1 is better than the second standard conversion sequence of
3236 // List-initialization sequence L1 is a better conversion sequence than
3264 // Per 13.3.3.2p3, compare the given standard conversion sequences to
3273 // the identity conversion sequence is considered to be a subsequence of
3274 // any non-identity conversion sequence
3336 /// conversion sequences to determine whether one is better than the
3343 // Standard conversion sequence S1 is a better conversion sequence
3344 // than standard conversion sequence S2 if (C++ 13.3.3.2p3):
3346 // -- S1 is a proper subsequence of S2 (comparing the conversion
3348 // excluding any Lvalue Transformation; the identity conversion
3350 // non-identity conversion sequence) or, if not that,
3364 // (C++ 13.3.3.2p4): Two conversion sequences with the same rank
3368 // A conversion that is not a conversion of a pointer, or
3369 // pointer to member, to bool is better than another conversion
3370 // that is such a conversion.
3379 // conversion of B* to A* is better than conversion of B* to
3380 // void*, and conversion of A* to void* is better than conversion
3387 // Exactly one of the conversion sequences is a conversion to
3388 // a void pointer; it's the worse conversion.
3392 // Neither conversion sequence converts to a void pointer; compare
3399 // Both conversion sequences are conversions to void
3406 // conversion, if we need to.
3487 // In Microsoft mode, prefer an integral conversion to a
3488 // floating-to-integral conversion if the integral conversion
3509 /// CompareQualificationConversions - Compares two standard conversion
3517 // -- S1 and S2 differ only in their qualification conversion and
3521 // deprecated string literal array-to-pointer conversion (4.2).
3527 // conversion (!)
3564 // conversion. Then, if all is well, we unwrap one more level of
3600 // Check that the winning standard conversion sequence isn't using
3601 // the deprecated string literal array to pointer conversion.
3620 /// CompareDerivedToBaseConversions - Compares two standard conversion
3635 // conversion, if we need to.
3667 // -- conversion of C* to B* is better than conversion of C* to A*,
3675 // -- conversion of B* to A* is better than conversion of C* to A*,
3694 // Apply the same conversion ranking rules for Objective-C pointer types
3707 // A conversion to an a non-id object pointer type or qualified 'id'
3708 // type is better than a conversion to 'id'.
3716 // A conversion to a non-id object pointer type is better than a
3717 // conversion to a qualified 'id' type
3723 // A conversion to an a non-Class object pointer type or qualified 'Class'
3724 // type is better than a conversion to 'Class'.
3732 // A conversion to a non-Class object pointer type is better than a
3733 // conversion to a qualified 'Class' type.
3739 // -- "conversion of C* to B* is better than conversion of C* to A*,"
3746 // -- "conversion of B* to A* is better than conversion of C* to A*,"
3774 // conversion of A::* to B::* is better than conversion of A::* to C::*,
3781 // conversion of B::* to C::* is better than conversion of A::* to C::*
3791 // -- conversion of C to B is better than conversion of C to A,
3803 // -- conversion of B to A is better than conversion of C to A.
3898 /// \brief Look for a user-defined conversion to an value reference-compatible
3927 // If this is an explicit conversion, and we're not allowed to consider
3937 // If we are initializing an rvalue reference, don't permit conversion
3956 // If the conversion function doesn't return a reference type,
3957 // it can't be considered for this conversion. An rvalue reference
3984 // applying a conversion function to the argument
3985 // expression, the implicit conversion sequence is a
3986 // user-defined conversion sequence (13.3.3.1.2), with the
3987 // second standard conversion sequence either an identity
3988 // conversion or, if the conversion function returns an
3990 // type, a derived-to-base Conversion.
4018 // There was no suitable conversion, or we found a deleted
4019 // conversion; continue with other checks.
4026 /// \brief Compute an implicit conversion sequence for reference
4035 // Most paths end in a failed conversion.
4077 // to an argument expression, the implicit conversion sequence
4078 // is the identity conversion, unless the argument expression
4080 // in which case the implicit conversion sequence is a
4081 // derived-to-base Conversion (13.3.3.1).
4103 // computing the implicit conversion sequence (C++
4112 // conversion is selected by enumerating the applicable
4113 // conversion functions (13.3.1.6) and choosing the best
4131 // binding by only attempting a simple conversion for non-direct
4184 // expression in the first case and to the result of the conversion
4193 // and the second standard conversion sequence of the
4194 // user-defined conversion sequence includes an lvalue-to-rvalue
4195 // conversion, the program is ill-formed.
4245 // an argument expression, the conversion sequence is the one
4248 // 13.3.3.1. Conceptually, this conversion sequence corresponds
4252 // and does not constitute a conversion.
4322 // conversion sequence is the worst conversion necessary to convert an
4342 // Otherwise, look for the worst conversion.
4349 // For an empty list, we won't have computed any conversion sequence.
4350 // Introduce the identity conversion sequence.
4366 // conversion sequence is a user-defined conversion sequence. If multiple
4368 // implicit conversion sequence is a user-defined conversion sequence.
4381 // initialized from the initializer list [...] the implicit conversion
4382 // sequence is a user-defined conversion sequence.
4454 "Sub-initialization cannot result in ellipsis conversion.");
4476 // - if the initializer list has one element, the implicit conversion
4485 // - if the initializer list has no elements, the implicit conversion
4486 // sequence is the identity conversion.
4498 // In all cases other than those enumerated above, no conversion is possible
4503 /// ToType from the expression From. Return the implicit conversion
4505 /// conversion sequence (meaning that the argument cannot be passed to
4507 /// do not permit any user-defined conversion sequences.
4559 // Set up the conversion sequence as a "bad" conversion, to allow us
4587 // However, when finding an implicit conversion sequence for the argument, we
4604 // affects the conversion rank.
4735 /// PerformContextuallyConvertToBool - Perform a contextual conversion
4752 /// Check that the specified conversion is permitted in a converted constant
4753 /// expression, according to C++11 [expr.const]p3. Return true if the conversion
4758 // type, most conversion kinds are impossible. All possible First and Third
4767 // Conversion from an integral or unscoped enumeration type to bool is
4769 // conversion, so it's permitted in a converted constant expression.
4795 llvm_unreachable("unexpected second conversion kind");
4801 llvm_unreachable("unknown conversion kind");
4805 /// converted constant expression of type T, perform the conversion and produce
4819 // expression is a literal constant expression and the implicit conversion
4857 llvm_unreachable("ellipsis conversion in converted constant expression");
4864 // Check for a narrowing implicit conversion.
4870 // Implicit conversion to a narrower type, and the value is not a constant
4922 /// dropPointerConversions - If the given standard conversion sequence
4924 /// the result type of the conversion sequence.
4937 // Do an implicit conversion to 'id'.
4968 /// conversion of the expression From to an Objective-C pointer type.
4993 /// conversion to an integral or enumeration type.
4996 /// conversion.
5007 /// explicit conversion function (because no implicit conversion functions
5011 /// showing which conversion was picked.
5014 /// conversion function that could convert to integral or enumeration type.
5017 /// usable conversion function.
5019 /// \param ConvDiag The diagnostic to be emitted if we are calling a conversion
5068 // Look for a conversion to an integral or enumeration type.
5080 if (CXXConversionDecl *Conversion
5083 Conversion->getConversionType().getNonReferenceType(),
5085 if (Conversion->isExplicit())
5097 CXXConversionDecl *Conversion
5101 // conversion; use it.
5103 = Conversion->getConversionType().getNonReferenceType();
5113 Diag(Conversion->getLocation(), ExplicitConvNote)
5117 // explicit conversion function.
5122 ExprResult Result = BuildCXXMemberCallExpr(From, Found, Conversion,
5126 // Record usage of conversion in an implicit cast.
5137 // Apply this conversion.
5141 CXXConversionDecl *Conversion
5144 = Conversion->getConversionType().getNonReferenceType();
5153 ExprResult Result = BuildCXXMemberCallExpr(From, Found, Conversion,
5157 // Record usage of conversion in an implicit cast.
5191 /// conversions via constructors or conversion operators.
5289 // Determine the implicit conversion sequences for each of the
5294 // exist for each argument an implicit conversion sequence
5391 /// allow user-defined conversions via constructors or conversion
5450 // Determine the implicit conversion sequence for the object
5462 // Determine the implicit conversion sequences for each of the
5467 // exist for each argument an implicit conversion sequence
5591 /// AddConversionCandidate - Add a C++ conversion function as a
5596 /// conversion function produces).
5598 Sema::AddConversionCandidate(CXXConversionDecl *Conversion,
5603 assert(!Conversion->getDescribedFunctionTemplate() &&
5604 "Conversion function templates use AddTemplateConversionCandidate");
5605 QualType ConvType = Conversion->getConversionType().getNonReferenceType();
5606 if (!CandidateSet.isNewCandidate(Conversion))
5615 Candidate.Function = Conversion;
5625 // For conversion functions, the function is considered to be a member of
5629 // Determine the implicit conversion sequence for the implicit
5640 Conversion, ConversionContext);
5648 // We won't go through a user-define type conversion function to convert a
5649 // derived to base as such conversions are given Conversion Rank. They only
5660 // To determine what the conversion from the result of calling the
5661 // conversion function to the type we're eventually trying to
5663 // conversion function and attempt copy initialization from it. This
5668 DeclRefExpr ConversionRef(Conversion, false, Conversion->getType(),
5671 Context.getPointerType(Conversion->getType()),
5675 QualType ConversionType = Conversion->getConversionType();
5701 // If the user-defined conversion is specified by a specialization of a
5702 // conversion function template, the second standard conversion sequence
5704 if (Conversion->getPrimaryTemplate() &&
5712 // the second standard conversion sequence of the user-defined
5713 // conversion sequence includes an lvalue-to-rvalue conversion, the
5729 "Can only end up with a standard conversion sequence or failure");
5733 /// \brief Adds a conversion function template specialization
5735 /// to deduce the template arguments of the conversion function
5745 "Only conversion function templates permitted here");
5768 // Add the conversion function template specialization produced by
5777 /// conversion function @c Conversion, and then attempts to call it
5780 void Sema::AddSurrogateCandidate(CXXConversionDecl *Conversion,
5787 if (!CandidateSet.isNewCandidate(Conversion))
5796 Candidate.Surrogate = Conversion;
5802 // Determine the implicit conversion sequence for the implicit
5807 Conversion, ActingContext);
5815 // The first conversion is actually a user-defined conversion whose
5816 // first conversion is ObjectInit's standard conversion (which is
5822 Candidate.Conversions[0].UserDefined.ConversionFunction = Conversion;
5849 // Determine the implicit conversion sequences for each of the
5854 // exist for each argument an implicit conversion sequence
5953 // Determine the implicit conversion sequences for each of the
5972 "Contextual conversion to bool requires bool type");
6186 /// AllowUserConversions is true if we should look at the conversion
6188 /// should also include the explicit conversion functions of a class
6241 // No conversion functions in incomplete types.
6254 // Skip conversion function templates; they don't tell us anything
6295 /// if any, found in visible type conversion functions found in ArgExpr's type.
7617 // conversion sequence than ICSi(F2), and then...
7626 // Cand1 has a better conversion sequence.
7640 // -- for some argument j, ICSj(F1) is a better conversion sequence than
7667 // -- the context is an initialization by user-defined conversion
7668 // (see 8.5, 13.3.1.5) and the standard conversion sequence
7671 // conversion sequence than the standard conversion sequence
7676 // First check whether we prefer one of the conversion functions over the
7678 // cases such as the conversion from a lambda closure type to a function
7689 // Cand1 has a better conversion sequence.
7813 assert(isa<CXXConversionDecl>(Meth) && "expected conversion");
7864 /// Diagnoses an ambiguous conversion. The partial diagnostic is the
7866 /// target types of the conversion.
7887 // There's a conversion slot for the object argument if this is a
7889 // conversion-slot index.
8077 // If we can fix the conversion, suggest the FixIts.
8328 // when user-conversion overload fails. Figure out how to handle
8482 // The conversion that can be fixed with a smaller number of changes,
8554 // Don't do anything on failures other than bad conversion.
8559 // Use a implicit copy initialization to check conversion fixes.
8562 // Skip forward to the first bad conversion.
8566 assert(ConvIdx != ConvCount && "no bad conversion in candidate");
8578 "remaining conversion is initialized?");
8600 // Builtin binary operator with a bad first conversion.
8687 // ambiguous user-defined conversion.
9957 // Do placeholder-like conversion on the LHS; note that we should
10585 /// user-defined conversion on the object argument.
10629 // In addition, for each (non-explicit in C++0x) conversion function
10632 // operator conversion-type-id () cv-qualifier;
10635 // greater cv-qualification than, cv, and where conversion-type-id
10642 // functions for each conversion function declared in an
10654 // Skip over templated conversion functions; they aren't
10727 // surrogate candidates. Dig out the conversion function.
10736 // object parameter to a function pointer. Perform the conversion
10739 // Create an implicit member expr to refer to the conversion operator.
10745 // Record usage of conversion in an implicit cast.
11080 assert(ICE->path_empty() && "fixing up hierarchy conversion?");
