Lines Matching refs:Expression
394 // Otherwise, find the sentinel expression.
454 // In C90 mode, arrays only promote to pointers if the array expression is
456 // type 'array of type' is converted to an expression that has type 'pointer
457 // to type'...". In C99 this was changed to: C99 6.3.2.1p3: "an expression
459 // (C90) to "an expression" (C99).
561 assert(!T.isNull() && "r-value conversion on typeless expression?");
650 /// performed on a function designator of a call expression.
692 // The following may be used in an expression wherever an int or
694 // - an object or expression with an integer type whose integer
761 /// Determine the degree of POD-ness for an expression.
856 // Strip the unbridged-cast placeholder expression off, if applicable.
914 /// \return false if the integer expression is an integer type and is
1294 // Semantic Analysis for various Expression Types
1396 // try to compute the result expression.
1412 // C11 6.5.1.1p2 "The controlling expression of a generic selection shall have
1416 // We strip parens here because the controlling expression is typically
1433 // its controlling expression shall have type compatible with exactly one of
1436 // We strip parens here because the controlling expression is typically
1445 // type name that is compatible with the type of the controlling expression,
1446 // then the result expression of the generic selection is the expression
1447 // in that generic association. Otherwise, the result expression of the
1448 // generic selection is the expression in the default generic association."
1629 /// BuildDeclRefExpr - Build an expression that references a
2018 // An id-expression is type-dependent if it contains:
2068 // id-expression.
2123 // LookupInObjCMethod build the appropriate expression to
2129 // lookup fails and no expression will be built to reference it.
2141 // When an id-expression that is not part of a class member access
2144 // resolves the name in the id-expression to a non-static non-type
2145 // member of some class C, the id-expression is transformed into a
2146 // class member access expression using (*this) as the
2147 // postfix-expression to the left of the . operator.
2151 // expression is ill-formed if it actually works out to be a
2156 // [t]he expression can be used only as the left-hand operand of a
2161 // spuriously dependent expression if we're inside a dependent
2587 // Only when used directly as the postfix-expression of a call.
2641 /// as an expression. This is only actually called for lookups that
2680 // Otherwise, just build an unresolved lookup expression. Suppress
2738 // must be the subject of a pointer-to-member expression.
2842 // result type, make the entire expression __unknown_anytype.
2876 // result type, make the entire expression __unknown_anytype.
3398 /// \brief Check the constraints on expression operands to unary type expression
3402 /// expression. The logic mostly mirrors the type-based overload, but may modify
3403 /// the expression as it completes the type for that expression through template
3419 // 'alignof' applied to an expression only requires the base element type of
3420 // the expression to be complete. 'sizeof' requires the expression's type to
3435 // Completing the expression's type may have changed it.
3476 /// \brief Check the constraints on operands to unary expression and type
3542 // Cannot know anything else if the expression is dependent.
3563 // in a way that is not transformed into a member access expression
3599 // Cannot know anything else if the expression is dependent.
3606 /// \brief Build a sizeof or alignof expression given a type operand.
3626 /// \brief Build a sizeof or alignof expression given an expression
3733 // Since this might is a postfix expression
3761 // Since this might be a postfix expression, get rid of ParenListExprs.
3784 // Build an unanalyzed expression if either operand is type-dependent.
3831 // C99 6.5.2.1p2: the expression e1[e2] is by definition precisely equivalent
3832 // to the expression *((e1)+(e2)). This means the array "Base" may actually be
3834 // and index from the expression types.
3851 // expression.
3970 // Instantiate the expression.
3982 // The names in the [default argument] expression are bound, and
3984 // default argument expression appears.
3992 // Check the expression as an initializer for the parameter.
4007 // Build the default argument expression.
4011 // If the default expression creates temporaries, we need to
4012 // push them to the current stack of expression temporaries so they'll
4017 // blocks in default argument expression can never capture anything.
4027 "default argument expression has capturing blocks?");
4031 // Just mark all of the declarations in this potentially-evaluated expression
4122 /// function prototype Proto. Call is the call expression itself, and
4123 /// Fn is the function expression. For a C++ member function, this
4266 // Strip the unbridged-cast placeholder expression off, if applicable.
4361 /// an array with at least as many elements as specified by the size expression.
4401 /// Given a function expression of unknown-any type, try to rebuild it
4469 // Since this might be a postfix expression, get rid of ParenListExprs.
4478 // If this is a pseudo-destructor expression, build the call immediately.
4540 OverloadExpr *ovl = find.Expression;
4627 /// ActOnConvertVectorExpr - create a new convert-vector expression from the
4640 /// BuildResolvedCallExpr - Build a call to a resolved expression,
4641 /// i.e. an expression not of \p OverloadTy. The expression should
4642 /// unary-convert to an expression of function-pointer or
4689 // C99 6.5.2.2p1 - "The expression that denotes the called function shall
4829 //assert((InitExpr != 0) && "ActOnCompoundLiteral(): missing expression");
4929 /// Prepare a conversion of the given expression to an ObjC object
5287 "Expected paren or paren list expression");
5389 /// \brief Emit a specialized diagnostic when one expression is a null pointer
5430 /// \brief Return false if the condition expression is valid, true otherwise.
5668 /// \brief Return false if the first expression is not an integer and the second
5669 /// expression is not a pointer, true otherwise.
5751 // FIXME: Type of conditional expression must be complete in C mode.
5795 // likely forgot to take the address of the other expression.
5969 /// expression, either using a built-in or overloaded operator,
5971 /// expression.
6016 /// or is a logical expression such as (x==y) which has int type, but is
6048 // The condition is an arithmetic binary expression, with a right-
6326 // Fake up an opaque expression. We don't actually care about what
6389 // LHSType so that the resulting expression does not have reference
6617 /// \brief Constructs a transparent union from an expression that is
6651 // It's compatible if the expression matches any of the fields.
6696 // expression is implicitly converted (C++ 4) to the
6762 // type of the assignment expression.
6765 // The getNonReferenceType() call makes sure that the resulting expression
6902 // Okay, the expression is invalid.
6921 // expression. These are mainly cases where the null pointer is used as an
6940 // what the other expression is.
6949 // if the other expression is a pointer.
7842 // Get the decl for a simple expression: a reference to a variable,
8454 /// Is the given expression (which must be 'const') a reference to a
8710 // C99 6.5.16p3: The type of an assignment expression is the type of the
8714 // is converted to the type of the assignment expression (above).
8715 // C++ 5.17p1: the type of the assignment expression is that of its left
8769 assert(!ResType.isNull() && "no type for increment/decrement expression");
8834 /// handle cases when the expression references a function designator
8853 // Otherwise, the expression refers to a part of the base
8881 // the sub-expression; otherwise, the result here doesn't matter.
8966 // (assuming the deref expression is valid).
8990 // The expression must have exactly the form &A::foo.
8992 // If the underlying expression isn't a decl ref, give up.
9001 // The id-expression was parenthesized.
9151 // [...] the expression to which [the unary * operator] is applied shall
9520 /// Emit a diagnostic together with a fixit hint that wraps the '&' expression
9535 /// Emit a diagnostic together with a fixit hint that wraps the '&&' expression
9549 /// \brief Returns true if the given expression can be evaluated as a constant
9557 /// \brief Returns true if the given expression can be evaluated as a constant
9692 assert(LHSExpr && "ActOnBinOp(): missing left expression");
9693 assert(RHSExpr && "ActOnBinOp(): missing right expression");
9701 /// Build an overloaded binary operator expression in the given scope.
9783 // If either expression is type-dependent, always build an
9788 // Otherwise, build an overloaded op if either expression has an
9960 /// \brief Determine whether the given expression is a qualified member
9961 /// access expression, of a form that could be turned into a pointer to member
10064 /// Given the last statement in a statement-expression, check whether
10065 /// the result is a producing expression (like a call to an
10067 /// release out of the full-expression. Otherwise, return null.
10116 // example, it is not possible to goto into a stmt expression apparently.
10133 // Do function/array conversion on the last expression, but not
10141 // In ARC, if the final expression ends in a consume, splice
10172 // FIXME: Check that expression type is complete/non-abstract; statement
10234 // The expression must be an integral expression.
10235 // FIXME: An integral constant expression?
10390 // The conditional expression is required to be a constant expression.
10442 // cleanups from the enclosing full-expression.
10457 // in turn, make the block expression contain unexpanded parameter packs.
10565 // Leave the expression-evaluation context.
10582 // Leave the expression-evaluation context.
10676 // First, this expression has a new cleanup object.
10714 // Make sure the input expression also decays appropriately.
10920 // expression, rather than a type), which should be done as part
11026 NoteAllOverloadCandidates(OverloadExpr::find(SrcExpr).Expression,
11084 // If an expression of literal class type is used in a context where an
11085 // integral constant expression is required, then that class type shall
11147 // Circumvent ICE checking in C++11 to avoid evaluating the expression twice
11159 // Try to evaluate the expression, and produce diagnostics explaining why it's
11160 // not a constant expression as a side-effect.
11164 // In C++11, we can rely on diagnostics being produced for any expression
11165 // which is not a constant expression. If no diagnostics were produced, then
11166 // this is a constant expression.
11202 // Handle the case where we conclude a expression which we speculatively
11294 // A lambda-expression shall not appear in an unevaluated operand
11299 // A conditional-expression e is a core constant expression unless the
11301 // evaluate [...] a lambda-expression.
11308 // during lambda expression creation.
11323 // the expression in that context: they aren't relevant because they
11338 // Pop the current expression evaluation context off the stack.
11365 // We are in an expression that is not potentially evaluated; do nothing.
11373 // We are in a potentially evaluated expression (or a constant-expression
11380 // containing expression is used.
11394 // A function whose name appears as a potentially-evaluated expression is
11416 // template argument, array bound or an expression in a braced-init-list),
11522 // expression evaluator needing to call back into Sema if it sees a
11576 expression outside of
11622 // Compute the type of an expression that refers to this variable.
11766 // full-expression.
11782 // Build a full-expression copy expression if initialization
11822 // by references. Since there is no capture by copy, no expression
11869 // When the lambda-expression is evaluated, the entities that
11879 // to be re-"exported" from the lambda expression itself.
11883 // An entity captured by a lambda-expression is odr-used (3.2) in
11884 // the scope containing the lambda-expression.
11964 // Exit the expression evaluation context used for the capture.
12063 // The closure type for a lambda-expression has a public inline
12065 // declared const (9.3.1) if and only if the lambda-expression?s
12348 // expression. Use this if you need to know if a variable that might or
12349 // might not be dependent is truly a constant expression.
12370 // constant expression (5.19) and the lvalue-to-rvalue conversion (4.1)
12376 expression, and if so, identify it as
12396 // If a constant-expression is a reference to a variable where we delay
12417 llvm_unreachable("Unexpcted expression");
12455 // until we finish analyzing the full expression for any lvalue-to-rvalue
12460 // expression (this will never need to be captured or odr-used).
12461 assert(E && "Capture variable should be used in an expression.");
12477 // in a constant expression.
12508 // constant expression.
12519 // the requirements for appearing in a constant expression (5.19) and, if
12527 // A reference initialized by a constant expression can never be
12586 // expression or a member of a set of candidate functions, if selected by
12588 // expression, is odr-used, unless it is a pure virtual function and its
12604 /// normal expression which refers to a variable.
12736 /// \brief Mark any declarations that appear within this expression or any
12794 // If we're inside a decltype's expression, don't check for a valid return
12954 /// A visitor for rebuilding a call to an __unknown_any expression
12973 /// Rebuild an expression which simply semantically wraps another
12974 /// expression which it shares the type and value kind of.
13031 /// Given a function expression of unknown-any type, try to rebuild it
13040 /// A visitor for rebuilding an expression of type __unknown_anytype
13042 /// expression. Strict preservation of the original source
13068 /// Rebuild an expression which simply semantically wraps another
13069 /// expression which it shares the type and value kind of.
13100 // Build the sub-expression as if it were an object of the pointee type.
13122 /// Rebuilds a call expression which yielded __unknown_anytype.
13261 // Rebuild the sub-expression as the pointee (function) type.
13277 // The sub-expression
13352 // Rewrite the casted expression from scratch.
