Lines Matching defs:expr
24 #include "clang/AST/Expr.h"
334 ArrayRef<Expr *> Args) {
395 Expr *sentinelExpr = Args[Args.size() - numArgsAfterSentinel - 1];
424 SourceRange Sema::getExprRange(Expr *E) const {
433 ExprResult Sema::DefaultFunctionArrayConversion(Expr *E) {
472 static void CheckForNullPointerDereference(Sema &S, Expr *E) {
481 isNullPointerConstant(S.Context, Expr::NPC_ValueDependentIsNotNull) &&
493 const Expr* RHS) {
503 const Expr *Base = OIRE->getBase();
547 ExprResult Sema::DefaultLvalueConversion(Expr *E) {
602 DiagnoseDirectIsaAccess(*this, OIRE, SourceLocation(), /* Expr*/nullptr);
639 ExprResult Sema::DefaultFunctionArrayLvalueConversion(Expr *E) {
651 ExprResult Sema::CallExprUnaryConversions(Expr *E) {
673 ExprResult Sema::UsualUnaryConversions(Expr *E) {
722 ExprResult Sema::DefaultArgumentPromotion(Expr *E) {
766 // C++11 [expr.call]p7:
785 // C++11 [expr.call]p7:
808 void Sema::checkVariadicArgument(const Expr *E, VariadicCallType CT) {
853 ExprResult Sema::DefaultVariadicArgumentPromotion(Expr *E, VariadicCallType CT,
1109 typedef ExprResult PerformCastFn(Sema &S, Expr *operand, QualType toType);
1114 ExprResult doIntegralCast(Sema &S, Expr *op, QualType toType) {
1118 ExprResult doComplexIntegralCast(Sema &S, Expr *op, QualType toType) {
1302 Expr *ControllingExpr,
1304 ArrayRef<Expr *> ArgExprs) {
1328 Expr *ControllingExpr,
1330 ArrayRef<Expr *> Exprs) {
1470 ArrayRef<Expr*> Args,
1587 Expr *Args[] = { Lit, LenArg };
1728 ArrayRef<Expr *> Args) {
1952 static Expr *
2017 // C++ [temp.dep.expr]p3:
2080 if (Expr *Ex = E.getAs<Expr>())
2101 if (Expr *E = recoverFromMSUnqualifiedLookup(*this, Context, NameInfo,
2154 // C++ [expr.ref]p4:
2343 // FIXME: This should use a new expr for a direct reference, don't
2415 return ExprResult((Expr *)nullptr);
2436 Sema::PerformObjectMemberConversion(Expr *From,
2946 default: llvm_unreachable("Unknown simple primary expr!");
2990 Expr *Lit = new (Context) CharacterLiteral(Literal.getValue(), Kind, Ty,
3017 static Expr *BuildFloatingLiteral(Sema &S, NumericLiteralParser &Literal,
3114 Expr *Lit;
3135 Expr *Lit = StringLiteral::Create(
3164 Expr *Res;
3312 ExprResult Sema::ActOnParenExpr(SourceLocation L, SourceLocation R, Expr *E) {
3313 assert(E && "ActOnParenExpr() missing expr");
3383 Expr *E) {
3405 bool Sema::CheckUnaryExprOrTypeTraitOperand(Expr *E,
3486 /// C++ [expr.sizeof]p4
3498 // C++ [expr.sizeof]p2:
3501 // C++11 [expr.alignof]p3:
3507 // C11 6.5.3.4/3, C++11 [expr.alignof]p3:
3539 static bool CheckAlignOfExpr(Sema &S, Expr *E) {
3596 bool Sema::CheckVecStepExpr(Expr *E) {
3629 Sema::CreateUnaryExprOrTypeTraitExpr(Expr *E, SourceLocation OpLoc,
3667 /// expr and the same for @c alignof and @c __alignof
3682 Expr *ArgEx = (Expr *)TyOrEx;
3725 tok::TokenKind Kind, Expr *Input) {
3746 Expr *op) {
3759 Sema::ActOnArraySubscriptExpr(Scope *S, Expr *base, SourceLocation lbLoc,
3760 Expr *idx, SourceLocation rbLoc) {
3810 Sema::CreateBuiltinArraySubscriptExpr(Expr *Base, SourceLocation LLoc,
3811 Expr *Idx, SourceLocation RLoc) {
3812 Expr *LHSExp = Base;
3813 Expr *RHSExp = Idx;
3835 Expr *BaseExpr, *IndexExpr;
3923 // C++ [expr.sub]p1: The type "T" shall be a completely-defined object
3965 Expr *UninstExpr = Param->getUninstantiatedDefaultArg();
3998 Expr *ResultE = Result.getAs<Expr>();
4005 Expr *Arg = Result.getAs<Expr>();
4041 Expr *Fn) {
4080 static TypoCorrection TryTypoCorrectionForCall(Sema &S, Expr *Fn,
4082 ArrayRef<Expr *> Args) {
4127 Sema::ConvertArgumentsForCall(CallExpr *Call, Expr *Fn,
4130 ArrayRef<Expr *> Args,
4229 SmallVector<Expr *, 8> AllArgs;
4245 unsigned FirstParam, ArrayRef<Expr *> Args,
4246 SmallVectorImpl<Expr *> &AllArgs,
4256 Expr *Arg;
4292 Arg = ArgE.getAs<Expr>();
4301 Arg = ArgExpr.getAs<Expr>();
4305 // check only triggers warnings when the argument isn't a more complex Expr
4365 const Expr *ArgExpr) {
4377 Expr::NPC_NeverValueDependent)) {
4403 static ExprResult rebuildUnknownAnyFunction(Sema &S, Expr *fn);
4466 Sema::ActOnCallExpr(Scope *S, Expr *Fn, SourceLocation LParenLoc,
4468 Expr *ExecConfig, bool IsExecConfig) {
4504 else if (Expr::hasAnyTypeDependentArguments(ArgExprs))
4559 Expr *NakedFn = Fn->IgnoreParens();
4611 ExprResult Sema::ActOnAsTypeExpr(Expr *E, ParsedType ParsedDestTy,
4632 ExprResult Sema::ActOnConvertVectorExpr(Expr *E, ParsedType ParsedDestTy,
4647 Sema::BuildResolvedCallExpr(Expr *Fn, NamedDecl *NDecl,
4649 ArrayRef<Expr *> Args,
4651 Expr *Config, bool IsExecConfig) {
4670 // Make the call expr early, before semantic checks. This guarantees cleanup
4738 TheCall->setValueKind(Expr::getValueKindForType(FuncT->getReturnType()));
4767 Expr *Arg = Args[i];
4777 Arg = ArgE.getAs<Expr>();
4785 Arg = ArgE.getAs<Expr>();
4826 SourceLocation RParenLoc, Expr *InitExpr) {
4841 SourceLocation RParenLoc, Expr *LiteralExpr) {
4999 Expr::NPC_ValueDependentIsNull))
5176 Expr *CastExpr, CastKind &Kind) {
5219 SourceLocation RParenLoc, Expr *CastExpr) {
5221 "ActOnCastExpr(): missing type or expr");
5250 Expr *E = (PE ? PE->getSubExpr() : PLE->getExpr(0));
5263 // If the Expr being casted is a ParenListExpr, handle it specially.
5284 SourceLocation RParenLoc, Expr *E,
5289 Expr **exprs;
5291 Expr *subExpr;
5309 SmallVector<Expr *, 8> initExprs;
5366 Sema::MaybeConvertParenListExprToParenExpr(Scope *S, Expr *OrigExpr) {
5385 Expr *expr = new (Context) ParenListExpr(Context, L, Val, R);
5386 return expr;
5392 bool Sema::DiagnoseConditionalForNull(Expr *LHSExpr, Expr *RHSExpr,
5394 Expr *NullExpr = LHSExpr;
5395 Expr *NonPointerExpr = RHSExpr;
5396 Expr::NullPointerConstantKind NullKind =
5398 Expr::NPC_ValueDependentIsNotNull);
5400 if (NullKind == Expr::NPCK_NotNull) {
5405 Expr::NPC_ValueDependentIsNotNull);
5408 if (NullKind == Expr::NPCK_NotNull)
5411 if (NullKind == Expr::NPCK_ZeroExpression)
5414 if (NullKind == Expr::NPCK_ZeroLiteral) {
5423 int DiagType = (NullKind == Expr::NPCK_CXX11_nullptr);
5431 static bool checkCondition(Sema &S, Expr *Cond) {
5475 Expr *LHSExpr = LHS.get();
5476 Expr *RHSExpr = RHS.get();
5495 Expr::NPC_ValueDependentIsNull))
5671 Expr* PointerExpr, SourceLocation Loc,
5677 Expr *Expr1 = IsIntFirstExpr ? Int.get() : PointerExpr;
5678 Expr *Expr2 = IsIntFirstExpr ? PointerExpr : Int.get();
5972 static bool IsArithmeticBinaryExpr(Expr *E, BinaryOperatorKind *Opcode,
5973 Expr **RHSExprs) {
6018 static bool ExprLooksBoolean(Expr *E) {
6037 Expr *Condition,
6038 Expr *LHSExpr,
6039 Expr *RHSExpr) {
6041 Expr *CondRHS;
6066 /// in the case of a the GNU conditional expr extension.
6069 Expr *CondExpr, Expr *LHSExpr,
6070 Expr *RHSExpr) {
6074 Expr *commonExpr = nullptr;
6624 Expr *E = EResult.get();
6665 Expr::NPC_ValueDependentIsNull)) {
6737 Expr::NPC_ValueDependentIsNull)) {
6769 Expr *E = RHS.get();
7019 Expr *LHSExpr, Expr *RHSExpr) {
7029 Expr *Pointer) {
7038 Expr *LHS, Expr *RHS) {
7054 Expr *Pointer) {
7068 Expr *Operand) {
7086 Expr *Operand) {
7114 Expr *LHSExpr, Expr *RHSExpr) {
7156 Expr *LHSExpr, Expr *RHSExpr) {
7158 Expr* IndexExpr = RHSExpr;
7195 Expr *LHSExpr, Expr *RHSExpr) {
7246 Expr *LHSExpr, Expr *RHSExpr) {
7284 Expr *PExp = LHS.get(), *IExp = RHS.get();
7381 // Pointee types must be the same: C++ [expr.add]
7457 // according to C++ has undefined behavior ([expr.shift] 5.8/2). Unsigned
7552 static void checkEnumComparison(Sema &S, SourceLocation Loc, Expr *LHS,
7553 Expr *RHS) {
7592 // C++ [expr.rel]p2:
7598 // C++ [expr.eq]p1 uses the same notion for (in)equality
7601 // C++ [expr.eq]p2:
7658 static bool hasIsEqualMethod(Sema &S, const Expr *LHS, const Expr *RHS) {
7708 Sema::ObjCLiteralKind Sema::CheckLiteralKind(Expr *FromE) {
7725 Expr *Inner = cast<ObjCBoxedExpr>(FromE)->getSubExpr()->IgnoreParens();
7753 Expr *Literal;
7754 Expr *Other;
7766 Expr::NPC_ValueDependentIsNotNull))
7814 Expr *SubExpr = UO->getSubExpr()->IgnoreImpCasts();
7844 static ValueDecl *getCompareDecl(Expr *E) {
7858 // C99 6.5.8, C++ [expr.rel]
7874 Expr *LHSStripped = LHS.get()->IgnoreParenImpCasts();
7875 Expr *RHSStripped = RHS.get()->IgnoreParenImpCasts();
7932 Expr *literalString = nullptr;
7933 Expr *literalStringStripped = nullptr;
7936 Expr::NPC_ValueDependentIsNull)) {
7942 Expr::NPC_ValueDependentIsNull)) {
7978 const Expr::NullPointerConstantKind LHSNullKind =
7979 LHS.get()->isNullPointerConstant(Context, Expr::NPC_ValueDependentIsNull);
7980 const Expr::NullPointerConstantKind RHSNullKind =
7981 RHS.get()->isNullPointerConstant(Context, Expr::NPC_ValueDependentIsNull);
7982 bool LHSIsNull = LHSNullKind != Expr::NPCK_NotNull;
7983 bool RHSIsNull = RHSNullKind != Expr::NPCK_NotNull;
8162 Expr *E = LHS.get();
8169 Expr *E = RHS.get();
8425 // C++ [expr.log.and]p1
8426 // C++ [expr.log.or]p1
8438 // C++ [expr.log.and]p2
8439 // C++ [expr.log.or]p2
8444 static bool IsReadonlyMessage(Expr *E, Sema &S) {
8458 static NonConstCaptureKind isReferenceToNonConstCapture(Sema &S, Expr *E) {
8487 static bool CheckForModifiableLvalue(Expr *E, SourceLocation Loc, Sema &S) {
8490 Expr::isModifiableLvalueResult IsLV = E->isModifiableLvalue(S.Context,
8492 if (IsLV == Expr::MLV_ClassTemporary && IsReadonlyMessage(E, S))
8493 IsLV = Expr::MLV_InvalidMessageExpression;
8494 if (IsLV == Expr::MLV_Valid)
8500 case Expr::MLV_ConstQualified:
8549 case Expr::MLV_ArrayType:
8550 case Expr::MLV_ArrayTemporary:
8554 case Expr::MLV_NotObjectType:
8558 case Expr::MLV_LValueCast:
8561 case Expr::MLV_Valid:
8563 case Expr::MLV_InvalidExpression:
8564 case Expr::MLV_MemberFunction:
8565 case Expr::MLV_ClassTemporary:
8568 case Expr::MLV_IncompleteType:
8569 case Expr::MLV_IncompleteVoidType:
8572 case Expr::MLV_DuplicateVectorComponents:
8575 case Expr::MLV_NoSetterProperty:
8577 case Expr::MLV_InvalidMessageExpression:
8580 case Expr::MLV_SubObjCPropertySetting:
8595 static void CheckIdentityFieldAssignment(Expr *LHSExpr, Expr *RHSExpr,
8618 QualType Sema::CheckAssignmentOperands(Expr *LHSExpr, ExprResult &RHS,
8632 Expr *RHSCheck = RHS.get();
8679 const Expr *InnerLHS = LHSExpr->IgnoreParenCasts();
8731 // C++'s comma does not do any conversions at all (C++ [expr.comma]p1).
8755 static QualType CheckIncrementDecrementOperand(Sema &S, Expr *Op,
8843 static ValueDecl *getPrimaryDecl(Expr *E) {
8858 Expr* Base = cast<ArraySubscriptExpr>(E)->getBase();
8901 Expr *E, unsigned Type) {
8915 Expr *E = OrigOp.get()->IgnoreParens();
8953 Expr *op = OrigOp.get()->IgnoreParens();
8973 Expr::LValueClassification lval = op->ClassifyLValue(Context);
8976 if (lval == Expr::LV_ClassTemporary || lval == Expr::LV_ArrayTemporary) {
8988 } else if (lval == Expr::LV_MemberFunction) {
9029 } else if (lval != Expr::LV_Valid && lval != Expr::LV_IncompleteVoidType) {
9094 if (lval == Expr::LV_IncompleteVoidType) {
9108 static QualType CheckIndirectionOperand(Sema &S, Expr *Op, ExprValueKind &VK,
9150 // C++ [expr.unary.op]p1:
9231 static void DiagnoseSelfAssignment(Sema &S, Expr *LHSExpr, Expr *RHSExpr,
9269 const Expr *ObjCPointerExpr = nullptr, *OtherExpr = nullptr;
9270 const Expr *LHS = L.get();
9271 const Expr *RHS = R.get();
9289 const Expr *Ex = ObjCPointerExpr->IgnoreParenCasts();
9310 Expr *LHSExpr, Expr *RHSExpr) {
9482 SourceLocation OpLoc, Expr *LHSExpr,
9483 Expr *RHSExpr) {
9519 /// \brief It accepts a '&' expr that is inside a '|' one.
9534 /// \brief It accepts a '&&' expr that is inside a '||' one.
9551 static bool EvaluatesAsTrue(Sema &S, Expr *E) {
9559 static bool EvaluatesAsFalse(Sema &S, Expr *E) {
9565 /// \brief Look for '&&' in the left hand of a '||' expr.
9567 Expr *LHSExpr, Expr *RHSExpr) {
9587 /// \brief Look for '&&' in the right hand of a '||' expr.
9589 Expr *LHSExpr, Expr *RHSExpr) {
9602 /// \brief Look for '&' in the left or right hand of a '|' expr.
9604 Expr *OrArg) {
9612 Expr *SubExpr, StringRef Shift) {
9626 Expr *LHSExpr, Expr *RHSExpr) {
9655 SourceLocation OpLoc, Expr *LHSExpr,
9656 Expr *RHSExpr){
9690 Expr *LHSExpr, Expr *RHSExpr) {
9704 Expr *LHS, Expr *RHS) {
9723 Expr *LHSExpr, Expr *RHSExpr) {
9801 Expr *InputExpr) {
9836 else if (getLangOpts().CPlusPlus && // C++ [expr.unary.op]p6
9891 // C++03 [expr.unary.op]p8, C++0x [expr.unary.op]p9:
9963 static bool isQualifiedMemberAccess(Expr *E) {
10003 UnaryOperatorKind Opc, Expr *Input) {
10051 tok::TokenKind Op, Expr *Input) {
10069 static Expr *maybeRebuildARCConsumingStmt(Stmt *Statement) {
10080 Expr *producer = cast->getSubExpr();
10132 if (Expr *LastE = dyn_cast<Expr>(LastStmt)) {
10147 if (Expr *rebuiltLastStmt
10174 Expr *ResStmtExpr = new (Context) StmtExpr(Compound, Ty, LPLoc, RPLoc);
10215 SmallVector<Expr*, 4> Exprs;
10229 ExprResult IdxRval = DefaultLvalueConversion(static_cast<Expr*>(OC.U.E));
10232 Expr *Idx = IdxRval.get();
10376 Expr *CondExpr,
10377 Expr *LHSExpr, Expr *RHSExpr,
10401 Expr *ActiveExpr = CondIsTrue ? LHSExpr : RHSExpr;
10695 Expr *E, ParsedType Ty,
10703 Expr *E, TypeSourceInfo *TInfo,
10705 Expr *OrigExpr = E;
10728 E = Init.getAs<Expr>();
10806 Sema::ConversionToObjCStringLiteralCheck(QualType DstType, Expr *&Exp) {
10824 Expr *SrcExpr = Exp->IgnoreParenImpCasts();
10841 Expr *SrcExpr, AssignmentAction Action,
11040 ExprResult Sema::VerifyIntegerConstantExpression(Expr *E,
11052 ExprResult Sema::VerifyIntegerConstantExpression(Expr *E,
11077 Sema::VerifyIntegerConstantExpression(Expr *E, llvm::APSInt *Result,
11083 // C++11 [expr.const]p5:
11155 Expr::EvalResult EvalResult;
11253 ExprResult Sema::TransformToPotentiallyEvaluated(Expr *E) {
11293 // C++11 [expr.prim.lambda]p2:
11298 // C++1y [expr.const]p2:
11350 ExprResult Sema::HandleExprEvaluationContextForTypeof(Expr *E) {
11722 Expr *CopyExpr = nullptr;
11772 Expr *DeclRef = new (S.Context) DeclRefExpr(Var, Nested,
11819 Expr *CopyExpr = nullptr;
11868 // C++11 [expr.prim.lambda]p21:
11882 // C++ [expr.prim.labda]p12:
11885 Expr *Ref = new (S.Context) DeclRefExpr(Var, RefersToEnclosingLocal,
11995 // C++11 [expr.prim.lambda]p15:
12009 // C++11 [expr.prim.lambda]p14:
12049 Expr *CopyExpr = nullptr;
12062 // C++ [expr.prim.lambda]p5:
12221 if (Expr *Size = Vat->getSizeExpr()) {
12360 Expr *Init = cast<Expr>(Eval->Value);
12367 void Sema::UpdateMarkingForLValueToRValue(Expr *E) {
12380 Expr *SansParensExpr = E->IgnoreParens();
12405 for (llvm::SmallPtrSetIterator<Expr*> i = MaybeODRUseExprs.begin(),
12429 VarDecl *Var, Expr *E) {
12431 "Invalid Expr argument to DoMarkVarDeclReferenced");
12544 Decl *D, Expr *E, bool OdrUse) {
12560 const Expr *Base = ME->getBase();
12741 void Sema::MarkDeclarationsReferencedInExpr(Expr *E,
12831 void Sema::DiagnoseAssignmentAsCondition(Expr *E) {
12898 Expr *E = ParenE->IgnoreParens();
12903 == Expr::MLV_Valid) {
12916 ExprResult Sema::CheckBooleanCondition(Expr *E, SourceLocation Loc) {
12946 Expr *SubExpr) {
12967 ExprResult VisitExpr(Expr *E) {
12979 Expr *SubExpr = SubResult.get();
12999 Expr *SubExpr = SubResult.get();
13007 ExprResult resolveDecl(Expr *E, ValueDecl *VD) {
13033 static ExprResult rebuildUnknownAnyFunction(Sema &S, Expr *FunctionExpr) {
13059 ExprResult VisitExpr(Expr *E) {
13073 Expr *SubExpr = SubResult.get();
13110 ExprResult resolveDecl(Expr *E, ValueDecl *VD);
13124 Expr *CalleeExpr = E->getCallee();
13137 CalleeType = Expr::findBoundMemberType(CalleeExpr);
13160 E->setValueKind(Expr::getValueKindForType(DestType));
13190 Expr *Arg = E->getArg(i);
13248 E->setValueKind(Expr::getValueKindForType(DestType));
13290 ExprResult RebuildUnknownAnyExpr::resolveDecl(Expr *E, ValueDecl *VD) {
13350 Expr *CastExpr, CastKind &CastKind,
13363 ExprResult Sema::forceUnknownAnyToType(Expr *E, QualType ToType) {
13368 Expr *arg, QualType ¶mType) {
13390 static ExprResult diagnoseUnknownAnyExpr(Sema &S, Expr *E) {
13391 Expr *orig = E;
13435 ExprResult Sema::CheckPlaceholderExpr(Expr *E) {
13467 Expr *realCast = stripARCUnbridgedCast(E);
13495 bool Sema::CheckCaseExpression(Expr *E) {
