Lines Matching defs:cast
807 auto CE = cast<CallExpr>(Call);
1471 auto *DRE = cast<DeclRefExpr>(TheCall->getCallee()->IgnoreParenCasts());
1982 StringRef Feature = cast<StringLiteral>(Arg)->getString();
3061 parms = cast<ObjCMethodDecl>(FDecl)->parameters();
3178 ? cast<FunctionDecl>(FDecl)->getNumParams()
3180 ? cast<ObjCMethodDecl>(FDecl)->param_size()
3207 Proto = cast<FunctionProtoType>(FDecl->getFunctionType());
3349 auto *Ctor = cast<CXXConstructorDecl>(FDecl);
3380 cast<CXXMemberCallExpr>(TheCall)->getImplicitObjectArgument();
3392 cast<CXXMethodDecl>(FDecl)->getFunctionObjectParameterType());
3522 CallExpr *TheCall = cast<CallExpr>(TheCallResult.get());
3523 DeclRefExpr *DRE =cast<DeclRefExpr>(TheCall->getCallee()->IgnoreParenCasts());
4127 DeclRefExpr *DRE = cast<DeclRefExpr>(Callee->IgnoreParenCasts());
4128 FunctionDecl *FDecl = cast<FunctionDecl>(DRE->getDecl());
4498 cast<DeclRefExpr>(TheCall->getCallee()->IgnoreParenCasts());
4499 FunctionDecl *FDecl = cast<FunctionDecl>(DRE->getDecl());
5144 << cast<FunctionDecl>(TheCall->getCalleeDecl())->getIdentifier();
5226 cast<FunctionDecl>(TheCall->getCalleeDecl())->getBuiltinID();
5307 DeclRefExpr *DRE =cast<DeclRefExpr>(TheCall->getCallee()->IgnoreParenCasts());
5308 FunctionDecl *FDecl = cast<FunctionDecl>(DRE->getDecl());
5695 cast<AbstractConditionalOperator>(E);
5737 E = cast<ImplicitCastExpr>(E)->getSubExpr();
5741 if (const Expr *src = cast<OpaqueValueExpr>(E)->getSourceExpr()) {
5754 const DeclRefExpr *DR = cast<DeclRefExpr>(E);
5832 IsVariadic = cast<FunctionProtoType>(FnTy)->isVariadic();
5870 const CallExpr *CE = cast<CallExpr>(E);
5908 const auto *ME = cast<ObjCMessageExpr>(E);
5943 StrE = cast<StringLiteral>(E);
5961 const BinaryOperator *BinOp = cast<BinaryOperator>(E);
5994 const UnaryOperator *UnaOp = cast<UnaryOperator>(E);
7309 // Check if we didn't match because of an implicit cast from a 'char'
7319 // implicit cast type also need to be signedness match otherwise we
7378 // a cast instead of changing the conversion specifier.
7415 // underlying type of a scoped enum (which always needs a cast).
7472 // add a cast to the recommended type (and correct the format string
7488 // If there's already a cast present, just replace it.
7494 // just write the C-style cast.
7498 // Otherwise, add parens around the expression as well as the cast.
7530 // and we should cast instead. Just use the normal warning message.
7604 // or inserting a cast to the target type.
8589 cast<IntegerLiteral>(E)->getValue() == 0) ||
8591 cast<CharacterLiteral>(E)->getValue() == 0);
9027 << CalleeName << 0 /*object: */ << cast<NamedDecl>(D);
9100 cast<FunctionDecl>(E->getCalleeDecl())->getQualifiedNameAsString();
9102 { // Prefer something that doesn't involve a cast to make things simpler.
9130 // Maybe the cast was important, check after the other cases.
9321 const BuiltinType *BT = cast<BuiltinType>(T);
9347 const BuiltinType *BT = cast<BuiltinType>(T);
9484 // user has an explicit widening cast, we should treat the value as
9504 // Bail out if the subexpr's range is as wide as the cast type.
9962 // the enumeration. In such a case, we should warn about the cast
10387 /// Diagnose an implicit cast; purely a helper for CheckImplicitConversion.
10402 /// Diagnose an implicit cast; purely a helper for CheckImplicitConversion.
10409 /// Diagnose an implicit cast from a floating point value to an integer value.
10537 const auto *RBT = cast<CompoundAssignOperator>(E)
10827 // If the vector cast is cast between two vectors of the same size, it is
10833 Source = cast<VectorType>(Source)->getElementType().getTypePtr();
10834 Target = cast<VectorType>(Target)->getElementType().getTypePtr();
10851 Source = cast<ComplexType>(Source)->getElementType().getTypePtr();
10852 Target = cast<ComplexType>(Target)->getElementType().getTypePtr();
10870 // If the vector cast is cast between two vectors of the same size, it is
10935 // implicit cast from a type matching the type the result
10936 // is being cast to.
10937 CallExpr *CEx = cast<CallExpr>(E);
12171 // Abbreviating pm-expression.*cast-expression as E1.*E2, [...]
12796 /// derived-to-base cast expression and the alignment and offset of the derived
12869 auto *CE = cast<CastExpr>(E);
12888 auto *ASE = cast<ArraySubscriptExpr>(E);
12893 if (auto *VD = dyn_cast<VarDecl>(cast<DeclRefExpr>(E)->getDecl())) {
12908 auto *ME = cast<MemberExpr>(E);
12926 auto *UO = cast<UnaryOperator>(E);
12936 auto *BO = cast<BinaryOperator>(E);
12964 auto *CE = cast<CastExpr>(E);
12990 auto *UO = cast<UnaryOperator>(E);
12996 auto *BO = cast<BinaryOperator>(E);
13032 // cast; don't do it if we're ignoring -Wcast_align (as is the default).
13204 // There's a cast to a different size type involved.
13281 const ArraySubscriptExpr *ASE = cast<ArraySubscriptExpr>(expr);
13288 expr = cast<MemberExpr>(expr)->getBase();
13292 const ArraySectionExpr *ASE = cast<ArraySectionExpr>(expr);
13302 const UnaryOperator *UO = cast<UnaryOperator>(expr);
13317 const ConditionalOperator *cond = cast<ConditionalOperator>(expr);
13325 const auto *OCE = cast<CXXOperatorCallExpr>(expr);
13360 // Strip off any implicit cast added to get to the one ARC-specific.
13361 while (ImplicitCastExpr *cast = dyn_cast<ImplicitCastExpr>(RHS)) {
13362 if (cast->getCastKind() == CK_ARCConsumeObject) {
13369 RHS = cast->getSubExpr();
13439 while (ImplicitCastExpr *cast = dyn_cast<ImplicitCastExpr>(RHS)) {
13440 if (cast->getCastKind() == CK_ARCConsumeObject) {
13445 RHS = cast->getSubExpr();
13803 cast<EnumType>(T1)->getDecl(),
13804 cast<EnumType>(T2)->getDecl());
13810 cast<RecordType>(T1)->getDecl(),
13811 cast<RecordType>(T2)->getDecl());
13866 const UnaryOperator *UO = cast<UnaryOperator>(TypeExpr);
13875 const DeclRefExpr *DRE = cast<DeclRefExpr>(TypeExpr);
13881 const IntegerLiteral *IL = cast<IntegerLiteral>(TypeExpr);
13893 cast<AbstractConditionalOperator>(TypeExpr);
13907 const BinaryOperator *BO = cast<BinaryOperator>(TypeExpr);
14046 // Skip implicit cast of pointer to `void *' (as a function argument).
14128 cast<UnaryOperator>(E)->getOpcode() == UO_AddrOf) {
14129 auto *Op = cast<UnaryOperator>(E)->getSubExpr()->IgnoreParens();