Cross Reference: /src/external/apache2/llvm/dist/clang/lib/Sema/SemaOverload.cpp

Lines Matching refs:Converted
269                                              const Expr *Converted) {
270   // We can have cleanups wrapping the converted expression; these need to be
272   if (auto *EWC = dyn_cast<ExprWithCleanups>(Converted)) {
279   while (auto *ICE = dyn_cast<ImplicitCastExpr>(Converted)) {
289       Converted = ICE->getSubExpr();
293       return Converted;
297   return Converted;
304 /// \param Converted  The result of applying this standard conversion sequence.
312     ASTContext &Ctx, const Expr *Converted, APValue &ConstantValue,
342   //    the original value when converted back to the original type, or
351       const Expr *Initializer = IgnoreNarrowingConversion(Ctx, Converted);
390       const Expr *Initializer = IgnoreNarrowingConversion(Ctx, Converted);
421   //    value when converted back to the original type.
435       const Expr *Initializer = IgnoreNarrowingConversion(Ctx, Converted);
1494 /// converted expression. Flavor is the kind of conversion we're
1765   //   be converted to a prvalue.
1788     // bound of T" can be converted to an rvalue of type "pointer to
1815     // An lvalue of function type T can be converted to an rvalue of
1992   // If we have not converted the argument type to the parameter type,
2070   // unsigned short int can be converted to an rvalue of type int if
2072   // the source rvalue can be converted to an rvalue of type unsigned
2089   //   fixed (7.2) can be converted to an rvalue a prvalue of the first of the
2095   //   type can be converted to an rvalue a prvalue of the extended integer type
2101   //   can be converted to a prvalue of its underlying type. Moreover, if
2104   //   converted to a prvalue of the promoted underlying type.
2137   //   A prvalue of type char16_t, char32_t, or wchar_t (3.9.1) can be converted
2143   //   or wchar_t can be converted to an rvalue a prvalue of its underlying
2172   // An rvalue for an integral bit-field (9.6) can be converted to an
2174   // bit-field; otherwise, it can be converted to unsigned int if
2212   // An rvalue of type bool can be converted to an rvalue of type int,
2227       /// An rvalue of type float can be converted to an rvalue of type
2338 /// can be converted to the type ToType via a pointer conversion (C++
2339 /// 4.10). If so, returns true and places the converted type (that
2368   // Blocks: Block pointers can be converted to void*.
2374   // Blocks: A null pointer constant can be converted to a block
2394   // A null pointer constant can be converted to a pointer type (C++ 4.10p1).
2423   // can be converted to an rvalue of type "pointer to cv void" (C++
2456   //   can be converted to an rvalue of type "pointer to cv B," where
2461   //   derived class object. The null pointer value is converted to
3069 /// converted to the type ToType via a member pointer conversion (C++ 4.11).
3070 /// If so, returns true and places the converted type (that might differ from
3080   // A null pointer constant can be converted to a member pointer (C++ 4.11p1)
3093   // A pointer to member of B can be converted to a pointer to member of D,
4537   //   a prvalue of type "pointer to cv2 T2" can be converted to the type
4821     //          converted to an lvalue of type "cv3 T3," where "cv1 T1"
4865   //               reference-related to T2, and can be implicitly converted to
5057   //   all the elements can be implicitly converted to X, the implicit
5065   //   can be implicitly converted to X, the implicit conversion sequence is
5551 /// Check that the specified conversion is permitted in a converted constant
5569     // conversion, so we allow it in a converted constant expression.
5619 /// converted constant expression of type T, perform the conversion and produce
5620 /// the converted expression, per C++11 [expr.const]p3.
5627          "converted constant expression outside C++11");
5633   //  A converted constant expression of type T is an expression,
5634   //  implicitly converted to type T, where the converted
5639   //  condition shall be a contextually converted constant expression of type
5669     llvm_unreachable("ellipsis conversion in converted constant expression");
5691            "unexpected class type converted constant expr");
5810   assert(T->isIntegralOrEnumerationType() && "unexpected converted const type");
6034 /// \returns The expression, converted to an integral or enumeration type if
6138     // is said to be contextually implicitly converted to a specified
6140     // converted to a type T that is determined as follows: E is searched
7281   // can be converted to the target type with a qualification conversion.
7718 /// converted to bool.
7973 /// Ty can be implicit converted to the given set of @p Types. We're
8017     // Member pointers are far easier, since the pointee can't be converted.
9064   // contextually converted to bool long ago. The candidates below are
OpenGrok
