Rewrite/Frontend/RewriteModernObjC.cpp

764                 !cast<ObjCInterfaceDecl>(*DI)->isThisDeclarationADefinition() &&
789                 !cast<ObjCProtocolDecl>(*DI)->isThisDeclarationADefinition() &&
972     // Synthesize an explicit cast to gain access to the ivar.
1031   // Synthesize an explicit cast to initialize the ivar.
1099   RewriteForwardClassEpilogue(cast<ObjCInterfaceDecl>(*I), typedefString);
1106     ObjCInterfaceDecl *ForwardDecl = cast<ObjCInterfaceDecl>(D[i]);
1114   RewriteForwardClassEpilogue(cast<ObjCInterfaceDecl>(D[0]), typedefString);
1471     cast<ObjCMessageExpr>(PseudoOp->getSemanticExpr(
1485       Base = cast<OpaqueValueExpr>(Base)->getSourceExpr();
1486       Base = cast<Expr>(RewriteFunctionBodyOrGlobalInitializer(Base));
1493         Arg = cast<OpaqueValueExpr>(Arg)->getSourceExpr();
1494       Arg = cast<Expr>(RewriteFunctionBodyOrGlobalInitializer(Arg));
1559     cast<ObjCMessageExpr>(PseudoOp->getResultExpr()->IgnoreImplicit());
1570       Base = cast<OpaqueValueExpr>(Base)->getSourceExpr();
1571       Base = cast<Expr>(RewriteFunctionBodyOrGlobalInitializer(Base));
1577         Arg = cast<OpaqueValueExpr>(Arg)->getSourceExpr();
1578       Arg = cast<Expr>(RewriteFunctionBodyOrGlobalInitializer(Arg));
1754     NamedDecl* D = cast<NamedDecl>(DS->getSingleDecl());
1755     QualType ElementType = cast<ValueDecl>(D)->getType();
1769     DeclRefExpr *DR = cast<DeclRefExpr>(S->getElement());
1771     ValueDecl *VD = cast<ValueDecl>(DR->getDecl());
2163   // Now, we cast the reference to a pointer to the objc_msgSend type.
2343     const TypeOfExprType *TypeOfExprTypePtr = cast<TypeOfExprType>(TypePtr);
2654   // cast to NSConstantString *
2655   CastExpr *cast = NoTypeInfoCStyleCastExpr(Context, Exp->getType(),
2657   ReplaceStmt(Exp, cast);
2659   return cast;
2669   CastExpr *cast = NoTypeInfoCStyleCastExpr(Context, Context->ObjCBuiltinBoolTy,
2672                                           cast);
2750   CastExpr *cast = NoTypeInfoCStyleCastExpr(Context,
2754   // Now do the "normal" pointer to function cast.
2758   cast = NoTypeInfoCStyleCastExpr(Context, castType, CK_BitCast,
2759                                   cast);
2762   ParenExpr *PE = new (Context) ParenExpr(StartLoc, EndLoc, cast);
2887   CastExpr *cast = NoTypeInfoCStyleCastExpr(Context,
2891   // Now do the "normal" pointer to function cast.
2895   cast = NoTypeInfoCStyleCastExpr(Context, castType, CK_BitCast,
2896                                   cast);
2899   ParenExpr *PE = new (Context) ParenExpr(StartLoc, EndLoc, cast);
3060   CastExpr *cast = NoTypeInfoCStyleCastExpr(Context,
3064   // Now do the "normal" pointer to function cast.
3068   cast = NoTypeInfoCStyleCastExpr(Context, castType, CK_BitCast,
3069                                   cast);
3072   ParenExpr *PE = new (Context) ParenExpr(StartLoc, EndLoc, cast);
3206   // Now do the "normal" pointer to function cast.
3385     // To turn off a warning, type-cast to 'id'
3406       // we need the cast below. For example:
3493     // To turn off a warning, type-cast to 'id'
3513       // we need the cast below. For example:
3599     // Make id<P...> cast into an 'id' cast.
3624   // Generate the funky cast.
3625   CastExpr *cast;
3659   // Need to cast objc_msgSend to "void *" (to workaround a GCC bandaid).
3660   // If we don't do this cast, we get the following bizarre warning/note:
3663   cast = NoTypeInfoCStyleCastExpr(Context,
3667   // Now do the "normal" pointer to function cast.
3668   // If we don't have a method decl, force a variadic cast.
3673   cast = NoTypeInfoCStyleCastExpr(Context, castType, CK_BitCast,
3674                                   cast);
3677   ParenExpr *PE = new (Context) ParenExpr(StartLoc, EndLoc, cast);
4247     const FunctionProtoType *FT = cast<FunctionProtoType>(AFT);
4678         InnerContexts.insert(cast<DeclContext>(CBE->getBlockDecl()));
4732   // Generate a funky cast.
4777                                       SourceLocation(), cast<Expr>(LHSStmt),
4778                                       SourceLocation(), cast<Expr>(RHSStmt),
4800   // Generate a funky cast.
4815   // Now do the pointer to function cast.
4940     const TypeOfExprType *TypeOfExprTypePtr = cast<TypeOfExprType>(TypePtr);
5477   // Get a pointer to the function type so we can cast appropriately.
5668     S = cast<OpaqueValueExpr>(S)->getSourceExpr();
5790   // and cast exprs.
5906       FunctionDecl *FD = cast<FunctionDecl>(D);
5939       ObjCMethodDecl *MD = cast<ObjCMethodDecl>(D);
5958       ObjCImplementationDecl *CI = cast<ObjCImplementationDecl>(D);
5963       ObjCCategoryImplDecl *CI = cast<ObjCCategoryImplDecl>(D);
5968       VarDecl *VD = cast<VarDecl>(D);
6017       RecordDecl *RD = cast<RecordDecl>(D);
6271   // NOTE! Windows uses LLP64 for 64bit mode. So, cast pointer to long long
7749     BaseExpr = cast<Expr>(RewriteFunctionBodyOrGlobalInitializer(BaseExpr));
7776       // cast offset to "char *".