Lines Matching refs:Expression
308 /// value of the expression prior to the narrowing conversion.
310 /// type of the expression prior to the narrowing conversion.
326 // type, except where the source is a constant expression and the actual
360 // where the source is a constant expression and the actual value after
391 // the source is a constant expression and the actual value after
622 Result.Data = Info.Expression;
827 /// preprocessing on the given expression.
1142 // A conversion of an expression of class type to the same class
1144 // expression of class type to a base class of that type is
1194 /// from the given expression (Expr) to the given type (ToType). This
1241 // A conversion of an expression of class type to the same class
1243 // expression of class type to a base class of that type is
1290 /// expression From to the type ToType. Returns the
1291 /// converted expression. Flavor is the kind of conversion we're
1425 /// expression From to the type ToType. Standard conversion sequences
1479 // Check if the "from" expression is taking the address of an overloaded
1482 // expression.
1496 "Non-address-of operator for overloaded function expression");
1720 // It's compatible if the expression matches any of the fields.
1732 /// expression From (whose potentially-adjusted type is FromType) to
1994 /// expression From, which has the (possibly adjusted) type FromType,
2626 /// expression From to the type ToType. This routine checks for
2698 /// expression From, which has the (possibly adjusted) type FromType, can be
2740 /// expression From to the type ToType. This routine checks for ambiguous or
3014 /// (C++ [over.ics.user]) that converts expression From to the type
3043 // copy-initialized from an expression of the same or a
3047 // that class. The argument list is the expression-list within
3949 // -- binding of an expression of type C to a reference of type
3950 // B& is better than binding an expression of type C to a
3961 // -- binding of an expression of type B to a reference of type
3962 // A& is better than binding an expression of type C to a
4157 // expression, the implicit conversion sequence is a
4234 // A reference to type "cv1 T1" is initialized by an expression
4237 // -- If reference is an lvalue reference and the initializer expression
4247 // to an argument expression, the implicit conversion sequence
4248 // is the identity conversion, unless the argument expression
4312 // -- If the initializer expression
4356 // expression in the first case and to the result of the conversion
4376 // initialized from the initializer expression using the
4410 // reference, the initializer expression shall not be an lvalue.
4417 // an argument expression, the conversion sequence is the one
4418 // required to convert the argument expression to the
4422 // the argument expression. Any difference in top-level
4480 // When an argument is an initializer list, it is not an expression and
4672 /// ToType from the expression From. Return the implicit conversion
4716 /// expression @p From.
4829 /// expression.
4891 /// expression From to bool (C++0x [conv]p3).
4904 /// of the expression From to bool (C++0x [conv]p3).
4921 /// expression, according to C++11 [expr.const]p3. Return true if the conversion
4938 // conversion, so it's permitted in a converted constant expression.
4973 /// CheckConvertedConstantExpression - Check that the expression From is a
4974 /// converted constant expression of type T, perform the conversion and produce
4975 /// the converted expression, per C++11 [expr.const]p3.
4979 assert(LangOpts.CPlusPlus11 && "converted constant expression outside C++11");
4986 // A converted constant expression of type T is a core constant expression,
4988 // expression is a literal constant expression and the implicit conversion
5026 llvm_unreachable("ellipsis conversion in converted constant expression");
5040 // expression. We'll diagnose this in a moment.
5056 // Check the expression is a constant expression.
5062 // The expression can't be folded, so we can't keep it at this position in
5069 // It's a constant expression.
5074 // It's not a constant expression. Produce an appropriate diagnostic.
5099 /// convert the expression From to an Objective-C pointer type.
5134 /// conversion of the expression From to an Objective-C pointer type.
5280 /// \brief Attempt to convert the given expression to a type which is accepted
5283 /// This routine will attempt to convert an expression of class type to a
5292 /// \param From The expression we're converting from.
5296 /// \returns The expression, converted to an integral or enumeration type if
5312 // If the expression already has a matching type, we're golden.
5401 // ... An expression e of class type E appearing in such a context
5547 // that is named without a member access expression (e.g.,
6071 /// C++ [over.match.copy]). From is the expression we're converting from,
6394 /// for the operator Op that was used in an operator expression such
6728 // expression for the purposes of conversions.
8484 OverloadExpr *OvlExpr = Ovl.Expression;
8974 << R.Expression->getName();
9667 OvlExpr(OvlExprInfo.Expression),
9813 // If the overload expression doesn't have the form of a pointer to
9966 /// expression with overloaded function type and @p ToType is the type
10016 /// \brief Given an expression that refers to an overloaded function, try to
10017 /// resolve that overloaded function expression down to a single function.
10106 // Resolve and fix an overloaded expression that can be resolved
10112 // expression, regardless of whether or not it succeeded. Always
10126 ovl.Expression, /*complain*/ false, &found)) {
10134 // Otherwise we'll end up making a bound member expression, which
10141 Diag(ovl.Expression->getExprLoc(),
10143 << 0 << ovl.Expression->getSourceRange();
10146 // static and non-static candidates (otherwise the expression
10154 // Fix the expression to refer to 'fn'.
10172 << ovl.Expression->getName()
10175 << ovl.Expression->getQualifierLoc().getSourceRange();
10491 // an expression with viable lookup results, which should never
10560 /// the completed call expression. If overload resolution fails, emits
10632 /// BuildOverloadedCallExpr - Given the call expression that calls Fn
10636 /// the call expression produced by overload resolution.
10783 // Build the actual expression node.
10885 // expression.
11009 // Build the actual expression node.
11146 // expression.
11219 // Build the actual expression node.
11305 /// function. MemExpr is the expression that refers to the member
11309 /// expression refers to a non-static member function or an overloaded
11319 // Dig out the member expression. This holds both the object
11575 // If the primary-expression E in the function call syntax
11842 /// (if one exists), where @c Base is an expression of class type and
11857 // [...] An expression x->m is interpreted as (x.operator->())->m
12034 /// CallExpr is set to a valid expression and FRS_Success returned on success,
12104 /// FixOverloadedFunctionReference - E is an expression that refers to
12107 /// to the function declaration Fn, so patch up the expression E to
