Rename the ARC cast kinds to start with "ARC".

git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@139466 91177308-0d34-0410-b5e6-96231b3b80d8

diff --git a/include/clang/AST/OperationKinds.h b/include/clang/AST/OperationKinds.h
index 677642213b2906d0c86d1c76f41ee880a48b0844..469da99a8cbf60d5c32f6289e8d718be173a169f 100644 (file)
--- a/include/clang/AST/OperationKinds.h
+++ b/include/clang/AST/OperationKinds.h
@@ -257,24 +257,24 @@ enum CastKind {
   /// \brief [ARC] Produces a retainable object pointer so that it may
   /// be consumed, e.g. by being passed to a consuming parameter.
   /// Calls objc_retain.
-  CK_ObjCProduceObject,
+  CK_ARCProduceObject,
 
   /// \brief [ARC] Consumes a retainable object pointer that has just
   /// been produced, e.g. as the return value of a retaining call.
   /// Enters a cleanup to call objc_release at some indefinite time.
-  CK_ObjCConsumeObject,
+  CK_ARCConsumeObject,
 
   /// \brief [ARC] Reclaim a retainable object pointer object that may
   /// have been produced and autoreleased as part of a function return
   /// sequence.
-  CK_ObjCReclaimReturnedObject,
+  CK_ARCReclaimReturnedObject,
 
   /// \brief [ARC] Causes a value of block type to be copied to the
   /// heap, if it is not already there.  A number of other operations
   /// in ARC cause blocks to be copied; this is for cases where that
   /// would not otherwise be guaranteed, such as when casting to a
   /// non-block pointer type.
-  CK_ObjCExtendBlockObject
+  CK_ARCExtendBlockObject
 };
 
 #define CK_Invalid ((CastKind) -1)

diff --git a/lib/ARCMigrate/TransProperties.cpp b/lib/ARCMigrate/TransProperties.cpp
index 1ce02b11ef4aec9889803c3d334f9f93ad2cf72d..ca845b6b330d236dc7f5e27f21b67ceaabe623d5 100644 (file)
--- a/lib/ARCMigrate/TransProperties.cpp
+++ b/lib/ARCMigrate/TransProperties.cpp
@@ -339,7 +339,7 @@ private:
       while (implCE && implCE->getCastKind() ==  CK_BitCast)
         implCE = dyn_cast<ImplicitCastExpr>(implCE->getSubExpr());
 
-      if (implCE && implCE->getCastKind() == CK_ObjCConsumeObject)
+      if (implCE && implCE->getCastKind() == CK_ARCConsumeObject)
         return false;
       }
 

diff --git a/lib/ARCMigrate/TransUnbridgedCasts.cpp b/lib/ARCMigrate/TransUnbridgedCasts.cpp
index 5f9159416b0d99800f383173f0582ffeca89400f..bc33c53b758d7de971ee7af55f64d7b21ced2196 100644 (file)
--- a/lib/ARCMigrate/TransUnbridgedCasts.cpp
+++ b/lib/ARCMigrate/TransUnbridgedCasts.cpp
@@ -237,9 +237,9 @@ private:
     }
 
     if (ImplicitCastExpr *implCE = dyn_cast<ImplicitCastExpr>(E->getSubExpr())){
-      if (implCE->getCastKind() == CK_ObjCConsumeObject)
+      if (implCE->getCastKind() == CK_ARCConsumeObject)
         return rewriteToBridgedCast(E, OBC_BridgeRetained);
-      if (implCE->getCastKind() == CK_ObjCReclaimReturnedObject)
+      if (implCE->getCastKind() == CK_ARCReclaimReturnedObject)
         return rewriteToBridgedCast(E, OBC_Bridge);
     }
   }

diff --git a/lib/AST/Expr.cpp b/lib/AST/Expr.cpp
index 63642b216feeaa8f0a978fc17f92287a2c8c174c..1168874a889d782e35e458ab00e02f801e400182 100644 (file)
--- a/lib/AST/Expr.cpp
+++ b/lib/AST/Expr.cpp
@@ -1076,10 +1076,10 @@ void CastExpr::CheckCastConsistency() const {
   case CK_IntegralComplexToReal:
   case CK_IntegralComplexCast:
   case CK_IntegralComplexToFloatingComplex:
-  case CK_ObjCProduceObject:
-  case CK_ObjCConsumeObject:
-  case CK_ObjCReclaimReturnedObject:
-  case CK_ObjCExtendBlockObject:
+  case CK_ARCProduceObject:
+  case CK_ARCConsumeObject:
+  case CK_ARCReclaimReturnedObject:
+  case CK_ARCExtendBlockObject:
     assert(!getType()->isBooleanType() && "unheralded conversion to bool");
     goto CheckNoBasePath;
 
@@ -1193,14 +1193,14 @@ const char *CastExpr::getCastKindName() const {
     return "IntegralComplexCast";
   case CK_IntegralComplexToFloatingComplex:
     return "IntegralComplexToFloatingComplex";
-  case CK_ObjCConsumeObject:
-    return "ObjCConsumeObject";
-  case CK_ObjCProduceObject:
-    return "ObjCProduceObject";
-  case CK_ObjCReclaimReturnedObject:
-    return "ObjCReclaimReturnedObject";
-  case CK_ObjCExtendBlockObject:
-    return "ObjCExtendBlockObject";
+  case CK_ARCConsumeObject:
+    return "ARCConsumeObject";
+  case CK_ARCProduceObject:
+    return "ARCProduceObject";
+  case CK_ARCReclaimReturnedObject:
+    return "ARCReclaimReturnedObject";
+  case CK_ARCExtendBlockObject:
+    return "ARCCExtendBlockObject";
   }
 
   llvm_unreachable("Unhandled cast kind!");

diff --git a/lib/AST/ExprConstant.cpp b/lib/AST/ExprConstant.cpp
index 7ae4186423164119029f4ab94f78e20852260c16..97786053be1833120360896b1d9620f0ccfb6daa 100644 (file)
--- a/lib/AST/ExprConstant.cpp
+++ b/lib/AST/ExprConstant.cpp
@@ -1827,10 +1827,10 @@ bool IntExprEvaluator::VisitCastExpr(const CastExpr *E) {
   case CK_GetObjCProperty:
   case CK_LValueBitCast:
   case CK_UserDefinedConversion:
-  case CK_ObjCProduceObject:
-  case CK_ObjCConsumeObject:
-  case CK_ObjCReclaimReturnedObject:
-  case CK_ObjCExtendBlockObject:
+  case CK_ARCProduceObject:
+  case CK_ARCConsumeObject:
+  case CK_ARCReclaimReturnedObject:
+  case CK_ARCExtendBlockObject:
     return false;
 
   case CK_LValueToRValue:
@@ -2336,10 +2336,10 @@ bool ComplexExprEvaluator::VisitCastExpr(const CastExpr *E) {
   case CK_FloatingComplexToBoolean:
   case CK_IntegralComplexToReal:
   case CK_IntegralComplexToBoolean:
-  case CK_ObjCProduceObject:
-  case CK_ObjCConsumeObject:
-  case CK_ObjCReclaimReturnedObject:
-  case CK_ObjCExtendBlockObject:
+  case CK_ARCProduceObject:
+  case CK_ARCConsumeObject:
+  case CK_ARCReclaimReturnedObject:
+  case CK_ARCExtendBlockObject:
     llvm_unreachable("invalid cast kind for complex value");
 
   case CK_LValueToRValue:

diff --git a/lib/CodeGen/CGExpr.cpp b/lib/CodeGen/CGExpr.cpp
index 520b1bbfb8a09b0d62ee9826c47c0686bb4c8f5d..d6ceef5e380b347d0b29fd89e8821503f00e2dd6 100644 (file)
--- a/lib/CodeGen/CGExpr.cpp
+++ b/lib/CodeGen/CGExpr.cpp
@@ -2059,10 +2059,10 @@ LValue CodeGenFunction::EmitCastLValue(const CastExpr *E) {
   case CK_BaseToDerivedMemberPointer:
   case CK_MemberPointerToBoolean:
   case CK_AnyPointerToBlockPointerCast:
-  case CK_ObjCProduceObject:
-  case CK_ObjCConsumeObject:
-  case CK_ObjCReclaimReturnedObject:
-  case CK_ObjCExtendBlockObject: {
+  case CK_ARCProduceObject:
+  case CK_ARCConsumeObject:
+  case CK_ARCReclaimReturnedObject:
+  case CK_ARCExtendBlockObject: {
     // These casts only produce lvalues when we're binding a reference to a 
     // temporary realized from a (converted) pure rvalue. Emit the expression
     // as a value, copy it into a temporary, and return an lvalue referring to

diff --git a/lib/CodeGen/CGExprAgg.cpp b/lib/CodeGen/CGExprAgg.cpp
index 93c7bd8af6f8fc8e92f27007adf7a3c0321857d9..f965cf7e3f00b580782c3a8c2608863487a8b7a5 100644 (file)
--- a/lib/CodeGen/CGExprAgg.cpp
+++ b/lib/CodeGen/CGExprAgg.cpp
@@ -379,10 +379,10 @@ void AggExprEmitter::VisitCastExpr(CastExpr *E) {
   case CK_IntegralComplexToBoolean:
   case CK_IntegralComplexCast:
   case CK_IntegralComplexToFloatingComplex:
-  case CK_ObjCProduceObject:
-  case CK_ObjCConsumeObject:
-  case CK_ObjCReclaimReturnedObject:
-  case CK_ObjCExtendBlockObject:
+  case CK_ARCProduceObject:
+  case CK_ARCConsumeObject:
+  case CK_ARCReclaimReturnedObject:
+  case CK_ARCExtendBlockObject:
     llvm_unreachable("cast kind invalid for aggregate types");
   }
 }

diff --git a/lib/CodeGen/CGExprComplex.cpp b/lib/CodeGen/CGExprComplex.cpp
index 326fcfa15bf86a3be4edc72536c979f4c7bf511f..5a752a1830de4d51bbe9878fdda6a2ebe1182776 100644 (file)
--- a/lib/CodeGen/CGExprComplex.cpp
+++ b/lib/CodeGen/CGExprComplex.cpp
@@ -411,10 +411,10 @@ ComplexPairTy ComplexExprEmitter::EmitCast(CastExpr::CastKind CK, Expr *Op,
   case CK_FloatingComplexToBoolean:
   case CK_IntegralComplexToReal:
   case CK_IntegralComplexToBoolean:
-  case CK_ObjCProduceObject:
-  case CK_ObjCConsumeObject:
-  case CK_ObjCReclaimReturnedObject:
-  case CK_ObjCExtendBlockObject:
+  case CK_ARCProduceObject:
+  case CK_ARCConsumeObject:
+  case CK_ARCReclaimReturnedObject:
+  case CK_ARCExtendBlockObject:
     llvm_unreachable("invalid cast kind for complex value");
 
   case CK_FloatingRealToComplex:

diff --git a/lib/CodeGen/CGExprConstant.cpp b/lib/CodeGen/CGExprConstant.cpp
index 7ab77709e03a63baf20665c3f7fd7c9fbef89f7a..c0b7045a52c5e98699fc5a6c8b01aa852fe69ee8 100644 (file)
--- a/lib/CodeGen/CGExprConstant.cpp
+++ b/lib/CodeGen/CGExprConstant.cpp
@@ -586,10 +586,10 @@ public:
     case CK_GetObjCProperty:
     case CK_ToVoid:
     case CK_Dynamic:
-    case CK_ObjCProduceObject:
-    case CK_ObjCConsumeObject:
-    case CK_ObjCReclaimReturnedObject:
-    case CK_ObjCExtendBlockObject:
+    case CK_ARCProduceObject:
+    case CK_ARCConsumeObject:
+    case CK_ARCReclaimReturnedObject:
+    case CK_ARCExtendBlockObject:
       return 0;
 
     // These might need to be supported for constexpr.

diff --git a/lib/CodeGen/CGExprScalar.cpp b/lib/CodeGen/CGExprScalar.cpp
index 6741f43366002849f69c9133db78fdbe09071624..01acd42a063f6dae870a641ee3d0b2df11791498 100644 (file)
--- a/lib/CodeGen/CGExprScalar.cpp
+++ b/lib/CodeGen/CGExprScalar.cpp
@@ -1115,16 +1115,16 @@ Value *ScalarExprEmitter::VisitCastExpr(CastExpr *CE) {
     return CGF.CGM.getCXXABI().EmitMemberPointerConversion(CGF, CE, Src);
   }
 
-  case CK_ObjCProduceObject:
+  case CK_ARCProduceObject:
     return CGF.EmitARCRetainScalarExpr(E);
-  case CK_ObjCConsumeObject:
+  case CK_ARCConsumeObject:
     return CGF.EmitObjCConsumeObject(E->getType(), Visit(E));
-  case CK_ObjCReclaimReturnedObject: {
+  case CK_ARCReclaimReturnedObject: {
     llvm::Value *value = Visit(E);
     value = CGF.EmitARCRetainAutoreleasedReturnValue(value);
     return CGF.EmitObjCConsumeObject(E->getType(), value);
   }
-  case CK_ObjCExtendBlockObject: {
+  case CK_ARCExtendBlockObject: {
     llvm::Value *value = CGF.EmitARCRetainScalarExpr(E);
     return CGF.EmitObjCConsumeObject(E->getType(), value);
   }

diff --git a/lib/CodeGen/CGObjC.cpp b/lib/CodeGen/CGObjC.cpp
index 037eed043059ae3fda2663881f71c30ef3f24b0c..ae6e95932532dd9924c9b7f397d7a488b9b54c54 100644 (file)
--- a/lib/CodeGen/CGObjC.cpp
+++ b/lib/CodeGen/CGObjC.cpp
@@ -1270,7 +1270,7 @@ void CodeGenFunction::EmitObjCAtSynchronizedStmt(
   CGM.getObjCRuntime().EmitSynchronizedStmt(*this, S);
 }
 
-/// Produce the code for a CK_ObjCProduceObject.  Just does a
+/// Produce the code for a CK_ARCProduceObject.  Just does a
 /// primitive retain.
 llvm::Value *CodeGenFunction::EmitObjCProduceObject(QualType type,
                                                     llvm::Value *value) {
@@ -1288,7 +1288,7 @@ namespace {
   };
 }
 
-/// Produce the code for a CK_ObjCConsumeObject.  Does a primitive
+/// Produce the code for a CK_ARCConsumeObject.  Does a primitive
 /// release at the end of the full-expression.
 llvm::Value *CodeGenFunction::EmitObjCConsumeObject(QualType type,
                                                     llvm::Value *object) {
@@ -1975,9 +1975,9 @@ static bool shouldEmitSeparateBlockRetain(const Expr *e) {
     switch (cast->getCastKind()) {
     // Emitting these operations in +1 contexts is goodness.
     case CK_LValueToRValue:
-    case CK_ObjCReclaimReturnedObject:
-    case CK_ObjCConsumeObject:
-    case CK_ObjCProduceObject:
+    case CK_ARCReclaimReturnedObject:
+    case CK_ARCConsumeObject:
+    case CK_ARCProduceObject:
       return false;
 
     // These operations preserve a block type.
@@ -2045,7 +2045,7 @@ tryEmitARCRetainScalarExpr(CodeGenFunction &CGF, const Expr *e) {
 
       // For consumptions, just emit the subexpression and thus elide
       // the retain/release pair.
-      case CK_ObjCConsumeObject: {
+      case CK_ARCConsumeObject: {
         llvm::Value *result = CGF.EmitScalarExpr(ce->getSubExpr());
         if (resultType) result = CGF.Builder.CreateBitCast(result, resultType);
         return TryEmitResult(result, true);
@@ -2054,7 +2054,7 @@ tryEmitARCRetainScalarExpr(CodeGenFunction &CGF, const Expr *e) {
       // Block extends are net +0.  Naively, we could just recurse on
       // the subexpression, but actually we need to ensure that the
       // value is copied as a block, so there's a little filter here.
-      case CK_ObjCExtendBlockObject: {
+      case CK_ARCExtendBlockObject: {
         llvm::Value *result; // will be a +0 value
 
         // If we can't safely assume the sub-expression will produce a
@@ -2087,7 +2087,7 @@ tryEmitARCRetainScalarExpr(CodeGenFunction &CGF, const Expr *e) {
 
       // For reclaims, emit the subexpression as a retained call and
       // skip the consumption.
-      case CK_ObjCReclaimReturnedObject: {
+      case CK_ARCReclaimReturnedObject: {
         llvm::Value *result = emitARCRetainCall(CGF, ce->getSubExpr());
         if (resultType) result = CGF.Builder.CreateBitCast(result, resultType);
         return TryEmitResult(result, true);

diff --git a/lib/Sema/SemaChecking.cpp b/lib/Sema/SemaChecking.cpp
index f0dd68759812b40eb2e23de64eb5d51079950ba0..b51e8313bdb9d0486dbc85bc71940b6fe1595fd0 100644 (file)
--- a/lib/Sema/SemaChecking.cpp
+++ b/lib/Sema/SemaChecking.cpp
@@ -3853,7 +3853,7 @@ static bool findRetainCycleOwner(Expr *e, RetainCycleOwner &owner) {
       case CK_BitCast:
       case CK_LValueBitCast:
       case CK_LValueToRValue:
-      case CK_ObjCReclaimReturnedObject:
+      case CK_ARCReclaimReturnedObject:
         e = cast->getSubExpr();
         continue;
 
@@ -4038,7 +4038,7 @@ bool Sema::checkUnsafeAssigns(SourceLocation Loc,
     return false;
   // strip off any implicit cast added to get to the one arc-specific
   while (ImplicitCastExpr *cast = dyn_cast<ImplicitCastExpr>(RHS)) {
-    if (cast->getCastKind() == CK_ObjCConsumeObject) {
+    if (cast->getCastKind() == CK_ARCConsumeObject) {
       Diag(Loc, diag::warn_arc_retained_assign)
         << (LT == Qualifiers::OCL_ExplicitNone) 
         << RHS->getSourceRange();
@@ -4069,7 +4069,7 @@ void Sema::checkUnsafeExprAssigns(SourceLocation Loc,
     unsigned Attributes = PD->getPropertyAttributes();
     if (Attributes & ObjCPropertyDecl::OBJC_PR_assign)
       while (ImplicitCastExpr *cast = dyn_cast<ImplicitCastExpr>(RHS)) {
-        if (cast->getCastKind() == CK_ObjCConsumeObject) {
+        if (cast->getCastKind() == CK_ARCConsumeObject) {
           Diag(Loc, diag::warn_arc_retained_property_assign)
           << RHS->getSourceRange();
           return;

diff --git a/lib/Sema/SemaExpr.cpp b/lib/Sema/SemaExpr.cpp
index ab699e8c8a8f498f5cfebcafd2afcfe418159f79..1828841b30f4cefb0c0b3b8434e4b87b8821f3e1 100644 (file)
--- a/lib/Sema/SemaExpr.cpp
+++ b/lib/Sema/SemaExpr.cpp
@@ -3792,7 +3792,7 @@ static void maybeExtendBlockObject(Sema &S, ExprResult &E) {
   if (!S.getLangOptions().ObjCAutoRefCount) return;
 
   E = ImplicitCastExpr::Create(S.Context, E.get()->getType(),
-                               CK_ObjCExtendBlockObject, E.get(),
+                               CK_ARCExtendBlockObject, E.get(),
                                /*base path*/ 0, VK_RValue);
   S.ExprNeedsCleanups = true;
 }
@@ -8283,7 +8283,7 @@ static Expr *maybeRebuildARCConsumingStmt(Stmt *Statement) {
   if (!cleanups) return 0;
 
   ImplicitCastExpr *cast = dyn_cast<ImplicitCastExpr>(cleanups->getSubExpr());
-  if (!cast || cast->getCastKind() != CK_ObjCConsumeObject)
+  if (!cast || cast->getCastKind() != CK_ARCConsumeObject)
     return 0;
 
   // Splice out the cast.  This shouldn't modify any interesting

diff --git a/lib/Sema/SemaExprCXX.cpp b/lib/Sema/SemaExprCXX.cpp
index b8b722503a6e9f9038de3be600a928398271f3a3..08f4c437c3eaeb1808740821daa82d35b7039b54 100644 (file)
--- a/lib/Sema/SemaExprCXX.cpp
+++ b/lib/Sema/SemaExprCXX.cpp
@@ -4095,8 +4095,8 @@ ExprResult Sema::MaybeBindToTemporary(Expr *E) {
 
     ExprNeedsCleanups = true;
 
-    CastKind ck = (ReturnsRetained ? CK_ObjCConsumeObject
-                                   : CK_ObjCReclaimReturnedObject);
+    CastKind ck = (ReturnsRetained ? CK_ARCConsumeObject
+                                   : CK_ARCReclaimReturnedObject);
     return Owned(ImplicitCastExpr::Create(Context, E->getType(), ck, E, 0,
                                           VK_RValue));
   }

diff --git a/lib/Sema/SemaExprObjC.cpp b/lib/Sema/SemaExprObjC.cpp
index faa678505bbbd3b460011734e7c704ecde8e54bf..51b5e4fb63b03dba602c257e0fa6d49a0aa0f36a 100644 (file)
--- a/lib/Sema/SemaExprObjC.cpp
+++ b/lib/Sema/SemaExprObjC.cpp
@@ -1821,7 +1821,7 @@ static Expr *maybeUndoReclaimObject(Expr *e) {
   // value-propagating subexpressions --- we can't reliably rebuild
   // in-place because of expression sharing.
   if (ImplicitCastExpr *ice = dyn_cast<ImplicitCastExpr>(e))
-    if (ice->getCastKind() == CK_ObjCReclaimReturnedObject)
+    if (ice->getCastKind() == CK_ARCReclaimReturnedObject)
       return ice->getSubExpr();
 
   return e;
@@ -1889,7 +1889,7 @@ ExprResult Sema::BuildObjCBridgedCast(SourceLocation LParenLoc,
     case OBC_BridgeRetained:        
       // Produce the object before casting it.
       SubExpr = ImplicitCastExpr::Create(Context, FromType,
-                                         CK_ObjCProduceObject,
+                                         CK_ARCProduceObject,
                                          SubExpr, 0, VK_RValue);
       break;
       
@@ -1925,7 +1925,7 @@ ExprResult Sema::BuildObjCBridgedCast(SourceLocation LParenLoc,
   
   if (MustConsume) {
     ExprNeedsCleanups = true;
-    Result = ImplicitCastExpr::Create(Context, T, CK_ObjCConsumeObject, Result, 
+    Result = ImplicitCastExpr::Create(Context, T, CK_ARCConsumeObject, Result, 
                                       0, VK_RValue);    
   }
   

diff --git a/lib/Sema/SemaInit.cpp b/lib/Sema/SemaInit.cpp
index bcdd4801ab64207c377afa8fbf741d93b04344a8..b4ff3c5154a1f2eb6fa421650b6fcbf49227a9c3 100644 (file)
--- a/lib/Sema/SemaInit.cpp
+++ b/lib/Sema/SemaInit.cpp
@@ -4662,7 +4662,7 @@ InitializationSequence::Perform(Sema &S,
 
     case SK_ProduceObjCObject:
       CurInit = S.Owned(ImplicitCastExpr::Create(S.Context, Step->Type,
-                                                 CK_ObjCProduceObject,
+                                                 CK_ARCProduceObject,
                                                  CurInit.take(), 0, VK_RValue));
       break;
     }

diff --git a/lib/StaticAnalyzer/Core/ExprEngineC.cpp b/lib/StaticAnalyzer/Core/ExprEngineC.cpp
index db4dc2f2fecc08fe1204818b904919c0ec824832..0daa252eccebac627b680d4d7e3d825ddfa75fa2 100644 (file)
--- a/lib/StaticAnalyzer/Core/ExprEngineC.cpp
+++ b/lib/StaticAnalyzer/Core/ExprEngineC.cpp
@@ -211,10 +211,10 @@ void ExprEngine::VisitCast(const CastExpr *CastE, const Expr *Ex,
         continue;
         // The analyzer doesn't do anything special with these casts,
         // since it understands retain/release semantics already.
-      case CK_ObjCProduceObject:
-      case CK_ObjCConsumeObject:
-      case CK_ObjCReclaimReturnedObject:
-      case CK_ObjCExtendBlockObject: // Fall-through.
+      case CK_ARCProduceObject:
+      case CK_ARCConsumeObject:
+      case CK_ARCReclaimReturnedObject:
+      case CK_ARCExtendBlockObject: // Fall-through.
         // True no-ops.
       case CK_NoOp:
       case CK_FunctionToPointerDecay: {