Rewrite/Frontend/RewriteObjC.cpp

687                 !cast<ObjCInterfaceDecl>(*DI)->isThisDeclarationADefinition() &&
706                 !cast<ObjCProtocolDecl>(*DI)->isThisDeclarationADefinition() &&
806     // Synthesize an explicit cast to gain access to the ivar.
864   // Synthesize an explicit cast to initialize the ivar.
914     ObjCInterfaceDecl *ForwardDecl = cast<ObjCInterfaceDecl>(*I);
926   RewriteForwardClassEpilogue(cast<ObjCInterfaceDecl>(*I), typedefString);
932     ObjCInterfaceDecl *ForwardDecl = cast<ObjCInterfaceDecl>(D[i]);
940   RewriteForwardClassEpilogue(cast<ObjCInterfaceDecl>(D[0]), typedefString);
1262     cast<ObjCMessageExpr>(PseudoOp->getSemanticExpr(
1275       Base = cast<OpaqueValueExpr>(Base)->getSourceExpr();
1276       Base = cast<Expr>(RewriteFunctionBodyOrGlobalInitializer(Base));
1280     RHS = cast<BinaryOperator>(PseudoOp->getSyntacticForm())->getRHS();
1281     RHS = cast<OpaqueValueExpr>(RHS)->getSourceExpr();
1282     RHS = cast<Expr>(RewriteFunctionBodyOrGlobalInitializer(RHS));
1345     cast<ObjCMessageExpr>(PseudoOp->getResultExpr()->IgnoreImplicit());
1356       Base = cast<OpaqueValueExpr>(Base)->getSourceExpr();
1357       Base = cast<Expr>(RewriteFunctionBodyOrGlobalInitializer(Base));
1517     NamedDecl* D = cast<NamedDecl>(DS->getSingleDecl());
1518     QualType ElementType = cast<ValueDecl>(D)->getType();
1532     DeclRefExpr *DR = cast<DeclRefExpr>(S->getElement());
1534     ValueDecl *VD = cast<ValueDecl>(DR->getDecl());
2053   // Now, we cast the reference to a pointer to the objc_msgSend type.
2229     const TypeOfExprType *TypeOfExprTypePtr = cast<TypeOfExprType>(TypePtr);
2554   // cast to NSConstantString *
2555   CastExpr *cast = NoTypeInfoCStyleCastExpr(Context, Exp->getType(),
2557   ReplaceStmt(Exp, cast);
2559   return cast;
2634   // Need to cast objc_msgSend_stret to "void *" (see above comment).
2635   CastExpr *cast = NoTypeInfoCStyleCastExpr(Context,
2638   // Now do the "normal" pointer to function cast.
2643   cast = NoTypeInfoCStyleCastExpr(Context, castType, CK_BitCast,
2644                                             cast);
2647   ParenExpr *PE = new (Context) ParenExpr(SourceLocation(), SourceLocation(), cast);
2739     // To turn off a warning, type-cast to 'id'
2760       // we need the cast below. For example:
2847     // To turn off a warning, type-cast to 'id'
2867       // we need the cast below. For example:
2953     // Make id<P...> cast into an 'id' cast.
2978   // Generate the funky cast.
2979   CastExpr *cast;
3013   // Need to cast objc_msgSend to "void *" (to workaround a GCC bandaid).
3014   // If we don't do this cast, we get the following bizarre warning/note:
3017   cast = NoTypeInfoCStyleCastExpr(Context,
3021   // Now do the "normal" pointer to function cast.
3022   // If we don't have a method decl, force a variadic cast.
3027   cast = NoTypeInfoCStyleCastExpr(Context, castType, CK_BitCast,
3028                                   cast);
3031   ParenExpr *PE = new (Context) ParenExpr(StartLoc, EndLoc, cast);
3344     const FunctionProtoType *FT = cast<FunctionProtoType>(AFT);
3752         InnerContexts.insert(cast<DeclContext>(CBE->getBlockDecl()));
3785   // Generate a funky cast.
3832                                       SourceLocation(), cast<Expr>(LHSStmt),
3833                                       SourceLocation(), cast<Expr>(RHSStmt),
3855   // Generate a funky cast.
3870   // Now do the pointer to function cast.
3995     const TypeOfExprType *TypeOfExprTypePtr = cast<TypeOfExprType>(TypePtr);
4506   // Get a pointer to the function type so we can cast appropriately.
4783   // and cast exprs.
4895       FunctionDecl *FD = cast<FunctionDecl>(D);
4929       ObjCMethodDecl *MD = cast<ObjCMethodDecl>(D);
4947       ObjCImplementationDecl *CI = cast<ObjCImplementationDecl>(D);
4952       ObjCCategoryImplDecl *CI = cast<ObjCCategoryImplDecl>(D);
4957       VarDecl *VD = cast<VarDecl>(D);
5004       RecordDecl *RD = cast<RecordDecl>(D);
5162   // NOTE! Windows uses LLP64 for 64bit mode. So, cast pointer to long long
5928     BaseExpr = cast<Expr>(RewriteFunctionBodyOrGlobalInitializer(BaseExpr));
5946       // Synthesize an explicit cast to gain access to the ivar.
5976     // Explicit ivar refs need to have a cast inserted.
5987       // Synthesize an explicit cast to gain access to the ivar.
6003       // Replace the old base with the cast. This is important when doing