Home | History | Annotate | Line # | Download | only in Edit 
      1 //===--- RewriteObjCFoundationAPI.cpp - Foundation API Rewriter -----------===//
      2 //
      3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
      4 // See https://llvm.org/LICENSE.txt for license information.
      5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
      6 //
      7 //===----------------------------------------------------------------------===//
      8 //
      9 // Rewrites legacy method calls to modern syntax.
     10 //
     11 //===----------------------------------------------------------------------===//
     12 
     13 #include "clang/Edit/Rewriters.h"
     14 #include "clang/AST/ASTContext.h"
     15 #include "clang/AST/ExprCXX.h"
     16 #include "clang/AST/ExprObjC.h"
     17 #include "clang/AST/NSAPI.h"
     18 #include "clang/AST/ParentMap.h"
     19 #include "clang/Edit/Commit.h"
     20 #include "clang/Lex/Lexer.h"
     21 
     22 using namespace clang;
     23 using namespace edit;
     24 
     25 static bool checkForLiteralCreation(const ObjCMessageExpr *Msg,
     26                                     IdentifierInfo *&ClassId,
     27                                     const LangOptions &LangOpts) {
     28   if (!Msg || Msg->isImplicit() || !Msg->getMethodDecl())
     29     return false;
     30 
     31   const ObjCInterfaceDecl *Receiver = Msg->getReceiverInterface();
     32   if (!Receiver)
     33     return false;
     34   ClassId = Receiver->getIdentifier();
     35 
     36   if (Msg->getReceiverKind() == ObjCMessageExpr::Class)
     37     return true;
     38 
     39   // When in ARC mode we also convert "[[.. alloc] init]" messages to literals,
     40   // since the change from +1 to +0 will be handled fine by ARC.
     41   if (LangOpts.ObjCAutoRefCount) {
     42     if (Msg->getReceiverKind() == ObjCMessageExpr::Instance) {
     43       if (const ObjCMessageExpr *Rec = dyn_cast<ObjCMessageExpr>(
     44                            Msg->getInstanceReceiver()->IgnoreParenImpCasts())) {
     45         if (Rec->getMethodFamily() == OMF_alloc)
     46           return true;
     47       }
     48     }
     49   }
     50 
     51   return false;
     52 }
     53 
     54 //===----------------------------------------------------------------------===//
     55 // rewriteObjCRedundantCallWithLiteral.
     56 //===----------------------------------------------------------------------===//
     57 
     58 bool edit::rewriteObjCRedundantCallWithLiteral(const ObjCMessageExpr *Msg,
     59                                               const NSAPI &NS, Commit &commit) {
     60   IdentifierInfo *II = nullptr;
     61   if (!checkForLiteralCreation(Msg, II, NS.getASTContext().getLangOpts()))
     62     return false;
     63   if (Msg->getNumArgs() != 1)
     64     return false;
     65 
     66   const Expr *Arg = Msg->getArg(0)->IgnoreParenImpCasts();
     67   Selector Sel = Msg->getSelector();
     68 
     69   if ((isa<ObjCStringLiteral>(Arg) &&
     70        NS.getNSClassId(NSAPI::ClassId_NSString) == II &&
     71        (NS.getNSStringSelector(NSAPI::NSStr_stringWithString) == Sel ||
     72         NS.getNSStringSelector(NSAPI::NSStr_initWithString) == Sel))   ||
     73 
     74       (isa<ObjCArrayLiteral>(Arg) &&
     75        NS.getNSClassId(NSAPI::ClassId_NSArray) == II &&
     76        (NS.getNSArraySelector(NSAPI::NSArr_arrayWithArray) == Sel ||
     77         NS.getNSArraySelector(NSAPI::NSArr_initWithArray) == Sel))     ||
     78 
     79       (isa<ObjCDictionaryLiteral>(Arg) &&
     80        NS.getNSClassId(NSAPI::ClassId_NSDictionary) == II &&
     81        (NS.getNSDictionarySelector(
     82                               NSAPI::NSDict_dictionaryWithDictionary) == Sel ||
     83         NS.getNSDictionarySelector(NSAPI::NSDict_initWithDictionary) == Sel))) {
     84 
     85     commit.replaceWithInner(Msg->getSourceRange(),
     86                            Msg->getArg(0)->getSourceRange());
     87     return true;
     88   }
     89 
     90   return false;
     91 }
     92 
     93 //===----------------------------------------------------------------------===//
     94 // rewriteToObjCSubscriptSyntax.
     95 //===----------------------------------------------------------------------===//
     96 
     97 /// Check for classes that accept 'objectForKey:' (or the other selectors
     98 /// that the migrator handles) but return their instances as 'id', resulting
     99 /// in the compiler resolving 'objectForKey:' as the method from NSDictionary.
    100 ///
    101 /// When checking if we can convert to subscripting syntax, check whether
    102 /// the receiver is a result of a class method from a hardcoded list of
    103 /// such classes. In such a case return the specific class as the interface
    104 /// of the receiver.
    105 ///
    106 /// FIXME: Remove this when these classes start using 'instancetype'.
    107 static const ObjCInterfaceDecl *
    108 maybeAdjustInterfaceForSubscriptingCheck(const ObjCInterfaceDecl *IFace,
    109                                          const Expr *Receiver,
    110                                          ASTContext &Ctx) {
    111   assert(IFace && Receiver);
    112 
    113   // If the receiver has type 'id'...
    114   if (!Ctx.isObjCIdType(Receiver->getType().getUnqualifiedType()))
    115     return IFace;
    116 
    117   const ObjCMessageExpr *
    118     InnerMsg = dyn_cast<ObjCMessageExpr>(Receiver->IgnoreParenCasts());
    119   if (!InnerMsg)
    120     return IFace;
    121 
    122   QualType ClassRec;
    123   switch (InnerMsg->getReceiverKind()) {
    124   case ObjCMessageExpr::Instance:
    125   case ObjCMessageExpr::SuperInstance:
    126     return IFace;
    127 
    128   case ObjCMessageExpr::Class:
    129     ClassRec = InnerMsg->getClassReceiver();
    130     break;
    131   case ObjCMessageExpr::SuperClass:
    132     ClassRec = InnerMsg->getSuperType();
    133     break;
    134   }
    135 
    136   if (ClassRec.isNull())
    137     return IFace;
    138 
    139   // ...and it is the result of a class message...
    140 
    141   const ObjCObjectType *ObjTy = ClassRec->getAs<ObjCObjectType>();
    142   if (!ObjTy)
    143     return IFace;
    144   const ObjCInterfaceDecl *OID = ObjTy->getInterface();
    145 
    146   // ...and the receiving class is NSMapTable or NSLocale, return that
    147   // class as the receiving interface.
    148   if (OID->getName() == "NSMapTable" ||
    149       OID->getName() == "NSLocale")
    150     return OID;
    151 
    152   return IFace;
    153 }
    154 
    155 static bool canRewriteToSubscriptSyntax(const ObjCInterfaceDecl *&IFace,
    156                                         const ObjCMessageExpr *Msg,
    157                                         ASTContext &Ctx,
    158                                         Selector subscriptSel) {
    159   const Expr *Rec = Msg->getInstanceReceiver();
    160   if (!Rec)
    161     return false;
    162   IFace = maybeAdjustInterfaceForSubscriptingCheck(IFace, Rec, Ctx);
    163 
    164   if (const ObjCMethodDecl *MD = IFace->lookupInstanceMethod(subscriptSel)) {
    165     if (!MD->isUnavailable())
    166       return true;
    167   }
    168   return false;
    169 }
    170 
    171 static bool subscriptOperatorNeedsParens(const Expr *FullExpr);
    172 
    173 static void maybePutParensOnReceiver(const Expr *Receiver, Commit &commit) {
    174   if (subscriptOperatorNeedsParens(Receiver)) {
    175     SourceRange RecRange = Receiver->getSourceRange();
    176     commit.insertWrap("(", RecRange, ")");
    177   }
    178 }
    179 
    180 static bool rewriteToSubscriptGetCommon(const ObjCMessageExpr *Msg,
    181                                         Commit &commit) {
    182   if (Msg->getNumArgs() != 1)
    183     return false;
    184   const Expr *Rec = Msg->getInstanceReceiver();
    185   if (!Rec)
    186     return false;
    187 
    188   SourceRange MsgRange = Msg->getSourceRange();
    189   SourceRange RecRange = Rec->getSourceRange();
    190   SourceRange ArgRange = Msg->getArg(0)->getSourceRange();
    191 
    192   commit.replaceWithInner(CharSourceRange::getCharRange(MsgRange.getBegin(),
    193                                                        ArgRange.getBegin()),
    194                          CharSourceRange::getTokenRange(RecRange));
    195   commit.replaceWithInner(SourceRange(ArgRange.getBegin(), MsgRange.getEnd()),
    196                          ArgRange);
    197   commit.insertWrap("[", ArgRange, "]");
    198   maybePutParensOnReceiver(Rec, commit);
    199   return true;
    200 }
    201 
    202 static bool rewriteToArraySubscriptGet(const ObjCInterfaceDecl *IFace,
    203                                        const ObjCMessageExpr *Msg,
    204                                        const NSAPI &NS,
    205                                        Commit &commit) {
    206   if (!canRewriteToSubscriptSyntax(IFace, Msg, NS.getASTContext(),
    207                                    NS.getObjectAtIndexedSubscriptSelector()))
    208     return false;
    209   return rewriteToSubscriptGetCommon(Msg, commit);
    210 }
    211 
    212 static bool rewriteToDictionarySubscriptGet(const ObjCInterfaceDecl *IFace,
    213                                             const ObjCMessageExpr *Msg,
    214                                             const NSAPI &NS,
    215                                             Commit &commit) {
    216   if (!canRewriteToSubscriptSyntax(IFace, Msg, NS.getASTContext(),
    217                                   NS.getObjectForKeyedSubscriptSelector()))
    218     return false;
    219   return rewriteToSubscriptGetCommon(Msg, commit);
    220 }
    221 
    222 static bool rewriteToArraySubscriptSet(const ObjCInterfaceDecl *IFace,
    223                                        const ObjCMessageExpr *Msg,
    224                                        const NSAPI &NS,
    225                                        Commit &commit) {
    226   if (!canRewriteToSubscriptSyntax(IFace, Msg, NS.getASTContext(),
    227                                    NS.getSetObjectAtIndexedSubscriptSelector()))
    228     return false;
    229 
    230   if (Msg->getNumArgs() != 2)
    231     return false;
    232   const Expr *Rec = Msg->getInstanceReceiver();
    233   if (!Rec)
    234     return false;
    235 
    236   SourceRange MsgRange = Msg->getSourceRange();
    237   SourceRange RecRange = Rec->getSourceRange();
    238   SourceRange Arg0Range = Msg->getArg(0)->getSourceRange();
    239   SourceRange Arg1Range = Msg->getArg(1)->getSourceRange();
    240 
    241   commit.replaceWithInner(CharSourceRange::getCharRange(MsgRange.getBegin(),
    242                                                        Arg0Range.getBegin()),
    243                          CharSourceRange::getTokenRange(RecRange));
    244   commit.replaceWithInner(CharSourceRange::getCharRange(Arg0Range.getBegin(),
    245                                                        Arg1Range.getBegin()),
    246                          CharSourceRange::getTokenRange(Arg0Range));
    247   commit.replaceWithInner(SourceRange(Arg1Range.getBegin(), MsgRange.getEnd()),
    248                          Arg1Range);
    249   commit.insertWrap("[", CharSourceRange::getCharRange(Arg0Range.getBegin(),
    250                                                        Arg1Range.getBegin()),
    251                     "] = ");
    252   maybePutParensOnReceiver(Rec, commit);
    253   return true;
    254 }
    255 
    256 static bool rewriteToDictionarySubscriptSet(const ObjCInterfaceDecl *IFace,
    257                                             const ObjCMessageExpr *Msg,
    258                                             const NSAPI &NS,
    259                                             Commit &commit) {
    260   if (!canRewriteToSubscriptSyntax(IFace, Msg, NS.getASTContext(),
    261                                    NS.getSetObjectForKeyedSubscriptSelector()))
    262     return false;
    263 
    264   if (Msg->getNumArgs() != 2)
    265     return false;
    266   const Expr *Rec = Msg->getInstanceReceiver();
    267   if (!Rec)
    268     return false;
    269 
    270   SourceRange MsgRange = Msg->getSourceRange();
    271   SourceRange RecRange = Rec->getSourceRange();
    272   SourceRange Arg0Range = Msg->getArg(0)->getSourceRange();
    273   SourceRange Arg1Range = Msg->getArg(1)->getSourceRange();
    274 
    275   SourceLocation LocBeforeVal = Arg0Range.getBegin();
    276   commit.insertBefore(LocBeforeVal, "] = ");
    277   commit.insertFromRange(LocBeforeVal, Arg1Range, /*afterToken=*/false,
    278                          /*beforePreviousInsertions=*/true);
    279   commit.insertBefore(LocBeforeVal, "[");
    280   commit.replaceWithInner(CharSourceRange::getCharRange(MsgRange.getBegin(),
    281                                                        Arg0Range.getBegin()),
    282                          CharSourceRange::getTokenRange(RecRange));
    283   commit.replaceWithInner(SourceRange(Arg0Range.getBegin(), MsgRange.getEnd()),
    284                          Arg0Range);
    285   maybePutParensOnReceiver(Rec, commit);
    286   return true;
    287 }
    288 
    289 bool edit::rewriteToObjCSubscriptSyntax(const ObjCMessageExpr *Msg,
    290                                         const NSAPI &NS, Commit &commit) {
    291   if (!Msg || Msg->isImplicit() ||
    292       Msg->getReceiverKind() != ObjCMessageExpr::Instance)
    293     return false;
    294   const ObjCMethodDecl *Method = Msg->getMethodDecl();
    295   if (!Method)
    296     return false;
    297 
    298   const ObjCInterfaceDecl *IFace =
    299       NS.getASTContext().getObjContainingInterface(Method);
    300   if (!IFace)
    301     return false;
    302   Selector Sel = Msg->getSelector();
    303 
    304   if (Sel == NS.getNSArraySelector(NSAPI::NSArr_objectAtIndex))
    305     return rewriteToArraySubscriptGet(IFace, Msg, NS, commit);
    306 
    307   if (Sel == NS.getNSDictionarySelector(NSAPI::NSDict_objectForKey))
    308     return rewriteToDictionarySubscriptGet(IFace, Msg, NS, commit);
    309 
    310   if (Msg->getNumArgs() != 2)
    311     return false;
    312 
    313   if (Sel == NS.getNSArraySelector(NSAPI::NSMutableArr_replaceObjectAtIndex))
    314     return rewriteToArraySubscriptSet(IFace, Msg, NS, commit);
    315 
    316   if (Sel == NS.getNSDictionarySelector(NSAPI::NSMutableDict_setObjectForKey))
    317     return rewriteToDictionarySubscriptSet(IFace, Msg, NS, commit);
    318 
    319   return false;
    320 }
    321 
    322 //===----------------------------------------------------------------------===//
    323 // rewriteToObjCLiteralSyntax.
    324 //===----------------------------------------------------------------------===//
    325 
    326 static bool rewriteToArrayLiteral(const ObjCMessageExpr *Msg,
    327                                   const NSAPI &NS, Commit &commit,
    328                                   const ParentMap *PMap);
    329 static bool rewriteToDictionaryLiteral(const ObjCMessageExpr *Msg,
    330                                   const NSAPI &NS, Commit &commit);
    331 static bool rewriteToNumberLiteral(const ObjCMessageExpr *Msg,
    332                                   const NSAPI &NS, Commit &commit);
    333 static bool rewriteToNumericBoxedExpression(const ObjCMessageExpr *Msg,
    334                                             const NSAPI &NS, Commit &commit);
    335 static bool rewriteToStringBoxedExpression(const ObjCMessageExpr *Msg,
    336                                            const NSAPI &NS, Commit &commit);
    337 
    338 bool edit::rewriteToObjCLiteralSyntax(const ObjCMessageExpr *Msg,
    339                                       const NSAPI &NS, Commit &commit,
    340                                       const ParentMap *PMap) {
    341   IdentifierInfo *II = nullptr;
    342   if (!checkForLiteralCreation(Msg, II, NS.getASTContext().getLangOpts()))
    343     return false;
    344 
    345   if (II == NS.getNSClassId(NSAPI::ClassId_NSArray))
    346     return rewriteToArrayLiteral(Msg, NS, commit, PMap);
    347   if (II == NS.getNSClassId(NSAPI::ClassId_NSDictionary))
    348     return rewriteToDictionaryLiteral(Msg, NS, commit);
    349   if (II == NS.getNSClassId(NSAPI::ClassId_NSNumber))
    350     return rewriteToNumberLiteral(Msg, NS, commit);
    351   if (II == NS.getNSClassId(NSAPI::ClassId_NSString))
    352     return rewriteToStringBoxedExpression(Msg, NS, commit);
    353 
    354   return false;
    355 }
    356 
    357 /// Returns true if the immediate message arguments of \c Msg should not
    358 /// be rewritten because it will interfere with the rewrite of the parent
    359 /// message expression. e.g.
    360 /// \code
    361 ///   [NSDictionary dictionaryWithObjects:
    362 ///                                 [NSArray arrayWithObjects:@"1", @"2", nil]
    363 ///                         forKeys:[NSArray arrayWithObjects:@"A", @"B", nil]];
    364 /// \endcode
    365 /// It will return true for this because we are going to rewrite this directly
    366 /// to a dictionary literal without any array literals.
    367 static bool shouldNotRewriteImmediateMessageArgs(const ObjCMessageExpr *Msg,
    368                                                  const NSAPI &NS);
    369 
    370 //===----------------------------------------------------------------------===//
    371 // rewriteToArrayLiteral.
    372 //===----------------------------------------------------------------------===//
    373 
    374 /// Adds an explicit cast to 'id' if the type is not objc object.
    375 static void objectifyExpr(const Expr *E, Commit &commit);
    376 
    377 static bool rewriteToArrayLiteral(const ObjCMessageExpr *Msg,
    378                                   const NSAPI &NS, Commit &commit,
    379                                   const ParentMap *PMap) {
    380   if (PMap) {
    381     const ObjCMessageExpr *ParentMsg =
    382         dyn_cast_or_null<ObjCMessageExpr>(PMap->getParentIgnoreParenCasts(Msg));
    383     if (shouldNotRewriteImmediateMessageArgs(ParentMsg, NS))
    384       return false;
    385   }
    386 
    387   Selector Sel = Msg->getSelector();
    388   SourceRange MsgRange = Msg->getSourceRange();
    389 
    390   if (Sel == NS.getNSArraySelector(NSAPI::NSArr_array)) {
    391     if (Msg->getNumArgs() != 0)
    392       return false;
    393     commit.replace(MsgRange, "@[]");
    394     return true;
    395   }
    396 
    397   if (Sel == NS.getNSArraySelector(NSAPI::NSArr_arrayWithObject)) {
    398     if (Msg->getNumArgs() != 1)
    399       return false;
    400     objectifyExpr(Msg->getArg(0), commit);
    401     SourceRange ArgRange = Msg->getArg(0)->getSourceRange();
    402     commit.replaceWithInner(MsgRange, ArgRange);
    403     commit.insertWrap("@[", ArgRange, "]");
    404     return true;
    405   }
    406 
    407   if (Sel == NS.getNSArraySelector(NSAPI::NSArr_arrayWithObjects) ||
    408       Sel == NS.getNSArraySelector(NSAPI::NSArr_initWithObjects)) {
    409     if (Msg->getNumArgs() == 0)
    410       return false;
    411     const Expr *SentinelExpr = Msg->getArg(Msg->getNumArgs() - 1);
    412     if (!NS.getASTContext().isSentinelNullExpr(SentinelExpr))
    413       return false;
    414 
    415     for (unsigned i = 0, e = Msg->getNumArgs() - 1; i != e; ++i)
    416       objectifyExpr(Msg->getArg(i), commit);
    417 
    418     if (Msg->getNumArgs() == 1) {
    419       commit.replace(MsgRange, "@[]");
    420       return true;
    421     }
    422     SourceRange ArgRange(Msg->getArg(0)->getBeginLoc(),
    423                          Msg->getArg(Msg->getNumArgs() - 2)->getEndLoc());
    424     commit.replaceWithInner(MsgRange, ArgRange);
    425     commit.insertWrap("@[", ArgRange, "]");
    426     return true;
    427   }
    428 
    429   return false;
    430 }
    431 
    432 //===----------------------------------------------------------------------===//
    433 // rewriteToDictionaryLiteral.
    434 //===----------------------------------------------------------------------===//
    435 
    436 /// If \c Msg is an NSArray creation message or literal, this gets the
    437 /// objects that were used to create it.
    438 /// \returns true if it is an NSArray and we got objects, or false otherwise.
    439 static bool getNSArrayObjects(const Expr *E, const NSAPI &NS,
    440                               SmallVectorImpl<const Expr *> &Objs) {
    441   if (!E)
    442     return false;
    443 
    444   E = E->IgnoreParenCasts();
    445   if (!E)
    446     return false;
    447 
    448   if (const ObjCMessageExpr *Msg = dyn_cast<ObjCMessageExpr>(E)) {
    449     IdentifierInfo *Cls = nullptr;
    450     if (!checkForLiteralCreation(Msg, Cls, NS.getASTContext().getLangOpts()))
    451       return false;
    452 
    453     if (Cls != NS.getNSClassId(NSAPI::ClassId_NSArray))
    454       return false;
    455 
    456     Selector Sel = Msg->getSelector();
    457     if (Sel == NS.getNSArraySelector(NSAPI::NSArr_array))
    458       return true; // empty array.
    459 
    460     if (Sel == NS.getNSArraySelector(NSAPI::NSArr_arrayWithObject)) {
    461       if (Msg->getNumArgs() != 1)
    462         return false;
    463       Objs.push_back(Msg->getArg(0));
    464       return true;
    465     }
    466 
    467     if (Sel == NS.getNSArraySelector(NSAPI::NSArr_arrayWithObjects) ||
    468         Sel == NS.getNSArraySelector(NSAPI::NSArr_initWithObjects)) {
    469       if (Msg->getNumArgs() == 0)
    470         return false;
    471       const Expr *SentinelExpr = Msg->getArg(Msg->getNumArgs() - 1);
    472       if (!NS.getASTContext().isSentinelNullExpr(SentinelExpr))
    473         return false;
    474 
    475       for (unsigned i = 0, e = Msg->getNumArgs() - 1; i != e; ++i)
    476         Objs.push_back(Msg->getArg(i));
    477       return true;
    478     }
    479 
    480   } else if (const ObjCArrayLiteral *ArrLit = dyn_cast<ObjCArrayLiteral>(E)) {
    481     for (unsigned i = 0, e = ArrLit->getNumElements(); i != e; ++i)
    482       Objs.push_back(ArrLit->getElement(i));
    483     return true;
    484   }
    485 
    486   return false;
    487 }
    488 
    489 static bool rewriteToDictionaryLiteral(const ObjCMessageExpr *Msg,
    490                                        const NSAPI &NS, Commit &commit) {
    491   Selector Sel = Msg->getSelector();
    492   SourceRange MsgRange = Msg->getSourceRange();
    493 
    494   if (Sel == NS.getNSDictionarySelector(NSAPI::NSDict_dictionary)) {
    495     if (Msg->getNumArgs() != 0)
    496       return false;
    497     commit.replace(MsgRange, "@{}");
    498     return true;
    499   }
    500 
    501   if (Sel == NS.getNSDictionarySelector(
    502                                     NSAPI::NSDict_dictionaryWithObjectForKey)) {
    503     if (Msg->getNumArgs() != 2)
    504       return false;
    505 
    506     objectifyExpr(Msg->getArg(0), commit);
    507     objectifyExpr(Msg->getArg(1), commit);
    508 
    509     SourceRange ValRange = Msg->getArg(0)->getSourceRange();
    510     SourceRange KeyRange = Msg->getArg(1)->getSourceRange();
    511     // Insert key before the value.
    512     commit.insertBefore(ValRange.getBegin(), ": ");
    513     commit.insertFromRange(ValRange.getBegin(),
    514                            CharSourceRange::getTokenRange(KeyRange),
    515                        /*afterToken=*/false, /*beforePreviousInsertions=*/true);
    516     commit.insertBefore(ValRange.getBegin(), "@{");
    517     commit.insertAfterToken(ValRange.getEnd(), "}");
    518     commit.replaceWithInner(MsgRange, ValRange);
    519     return true;
    520   }
    521 
    522   if (Sel == NS.getNSDictionarySelector(
    523                                   NSAPI::NSDict_dictionaryWithObjectsAndKeys) ||
    524       Sel == NS.getNSDictionarySelector(NSAPI::NSDict_initWithObjectsAndKeys)) {
    525     if (Msg->getNumArgs() % 2 != 1)
    526       return false;
    527     unsigned SentinelIdx = Msg->getNumArgs() - 1;
    528     const Expr *SentinelExpr = Msg->getArg(SentinelIdx);
    529     if (!NS.getASTContext().isSentinelNullExpr(SentinelExpr))
    530       return false;
    531 
    532     if (Msg->getNumArgs() == 1) {
    533       commit.replace(MsgRange, "@{}");
    534       return true;
    535     }
    536 
    537     for (unsigned i = 0; i < SentinelIdx; i += 2) {
    538       objectifyExpr(Msg->getArg(i), commit);
    539       objectifyExpr(Msg->getArg(i+1), commit);
    540 
    541       SourceRange ValRange = Msg->getArg(i)->getSourceRange();
    542       SourceRange KeyRange = Msg->getArg(i+1)->getSourceRange();
    543       // Insert value after key.
    544       commit.insertAfterToken(KeyRange.getEnd(), ": ");
    545       commit.insertFromRange(KeyRange.getEnd(), ValRange, /*afterToken=*/true);
    546       commit.remove(CharSourceRange::getCharRange(ValRange.getBegin(),
    547                                                   KeyRange.getBegin()));
    548     }
    549     // Range of arguments up until and including the last key.
    550     // The sentinel and first value are cut off, the value will move after the
    551     // key.
    552     SourceRange ArgRange(Msg->getArg(1)->getBeginLoc(),
    553                          Msg->getArg(SentinelIdx - 1)->getEndLoc());
    554     commit.insertWrap("@{", ArgRange, "}");
    555     commit.replaceWithInner(MsgRange, ArgRange);
    556     return true;
    557   }
    558 
    559   if (Sel == NS.getNSDictionarySelector(
    560                                   NSAPI::NSDict_dictionaryWithObjectsForKeys) ||
    561       Sel == NS.getNSDictionarySelector(NSAPI::NSDict_initWithObjectsForKeys)) {
    562     if (Msg->getNumArgs() != 2)
    563       return false;
    564 
    565     SmallVector<const Expr *, 8> Vals;
    566     if (!getNSArrayObjects(Msg->getArg(0), NS, Vals))
    567       return false;
    568 
    569     SmallVector<const Expr *, 8> Keys;
    570     if (!getNSArrayObjects(Msg->getArg(1), NS, Keys))
    571       return false;
    572 
    573     if (Vals.size() != Keys.size())
    574       return false;
    575 
    576     if (Vals.empty()) {
    577       commit.replace(MsgRange, "@{}");
    578       return true;
    579     }
    580 
    581     for (unsigned i = 0, n = Vals.size(); i < n; ++i) {
    582       objectifyExpr(Vals[i], commit);
    583       objectifyExpr(Keys[i], commit);
    584 
    585       SourceRange ValRange = Vals[i]->getSourceRange();
    586       SourceRange KeyRange = Keys[i]->getSourceRange();
    587       // Insert value after key.
    588       commit.insertAfterToken(KeyRange.getEnd(), ": ");
    589       commit.insertFromRange(KeyRange.getEnd(), ValRange, /*afterToken=*/true);
    590     }
    591     // Range of arguments up until and including the last key.
    592     // The first value is cut off, the value will move after the key.
    593     SourceRange ArgRange(Keys.front()->getBeginLoc(), Keys.back()->getEndLoc());
    594     commit.insertWrap("@{", ArgRange, "}");
    595     commit.replaceWithInner(MsgRange, ArgRange);
    596     return true;
    597   }
    598 
    599   return false;
    600 }
    601 
    602 static bool shouldNotRewriteImmediateMessageArgs(const ObjCMessageExpr *Msg,
    603                                                  const NSAPI &NS) {
    604   if (!Msg)
    605     return false;
    606 
    607   IdentifierInfo *II = nullptr;
    608   if (!checkForLiteralCreation(Msg, II, NS.getASTContext().getLangOpts()))
    609     return false;
    610 
    611   if (II != NS.getNSClassId(NSAPI::ClassId_NSDictionary))
    612     return false;
    613 
    614   Selector Sel = Msg->getSelector();
    615   if (Sel == NS.getNSDictionarySelector(
    616                                   NSAPI::NSDict_dictionaryWithObjectsForKeys) ||
    617       Sel == NS.getNSDictionarySelector(NSAPI::NSDict_initWithObjectsForKeys)) {
    618     if (Msg->getNumArgs() != 2)
    619       return false;
    620 
    621     SmallVector<const Expr *, 8> Vals;
    622     if (!getNSArrayObjects(Msg->getArg(0), NS, Vals))
    623       return false;
    624 
    625     SmallVector<const Expr *, 8> Keys;
    626     if (!getNSArrayObjects(Msg->getArg(1), NS, Keys))
    627       return false;
    628 
    629     if (Vals.size() != Keys.size())
    630       return false;
    631 
    632     return true;
    633   }
    634 
    635   return false;
    636 }
    637 
    638 //===----------------------------------------------------------------------===//
    639 // rewriteToNumberLiteral.
    640 //===----------------------------------------------------------------------===//
    641 
    642 static bool rewriteToCharLiteral(const ObjCMessageExpr *Msg,
    643                                    const CharacterLiteral *Arg,
    644                                    const NSAPI &NS, Commit &commit) {
    645   if (Arg->getKind() != CharacterLiteral::Ascii)
    646     return false;
    647   if (NS.isNSNumberLiteralSelector(NSAPI::NSNumberWithChar,
    648                                    Msg->getSelector())) {
    649     SourceRange ArgRange = Arg->getSourceRange();
    650     commit.replaceWithInner(Msg->getSourceRange(), ArgRange);
    651     commit.insert(ArgRange.getBegin(), "@");
    652     return true;
    653   }
    654 
    655   return rewriteToNumericBoxedExpression(Msg, NS, commit);
    656 }
    657 
    658 static bool rewriteToBoolLiteral(const ObjCMessageExpr *Msg,
    659                                    const Expr *Arg,
    660                                    const NSAPI &NS, Commit &commit) {
    661   if (NS.isNSNumberLiteralSelector(NSAPI::NSNumberWithBool,
    662                                    Msg->getSelector())) {
    663     SourceRange ArgRange = Arg->getSourceRange();
    664     commit.replaceWithInner(Msg->getSourceRange(), ArgRange);
    665     commit.insert(ArgRange.getBegin(), "@");
    666     return true;
    667   }
    668 
    669   return rewriteToNumericBoxedExpression(Msg, NS, commit);
    670 }
    671 
    672 namespace {
    673 
    674 struct LiteralInfo {
    675   bool Hex, Octal;
    676   StringRef U, F, L, LL;
    677   CharSourceRange WithoutSuffRange;
    678 };
    679 
    680 }
    681 
    682 static bool getLiteralInfo(SourceRange literalRange,
    683                            bool isFloat, bool isIntZero,
    684                           ASTContext &Ctx, LiteralInfo &Info) {
    685   if (literalRange.getBegin().isMacroID() ||
    686       literalRange.getEnd().isMacroID())
    687     return false;
    688   StringRef text = Lexer::getSourceText(
    689                                   CharSourceRange::getTokenRange(literalRange),
    690                                   Ctx.getSourceManager(), Ctx.getLangOpts());
    691   if (text.empty())
    692     return false;
    693 
    694   Optional<bool> UpperU, UpperL;
    695   bool UpperF = false;
    696 
    697   struct Suff {
    698     static bool has(StringRef suff, StringRef &text) {
    699       if (text.endswith(suff)) {
    700         text = text.substr(0, text.size()-suff.size());
    701         return true;
    702       }
    703       return false;
    704     }
    705   };
    706 
    707   while (1) {
    708     if (Suff::has("u", text)) {
    709       UpperU = false;
    710     } else if (Suff::has("U", text)) {
    711       UpperU = true;
    712     } else if (Suff::has("ll", text)) {
    713       UpperL = false;
    714     } else if (Suff::has("LL", text)) {
    715       UpperL = true;
    716     } else if (Suff::has("l", text)) {
    717       UpperL = false;
    718     } else if (Suff::has("L", text)) {
    719       UpperL = true;
    720     } else if (isFloat && Suff::has("f", text)) {
    721       UpperF = false;
    722     } else if (isFloat && Suff::has("F", text)) {
    723       UpperF = true;
    724     } else
    725       break;
    726   }
    727 
    728   if (!UpperU.hasValue() && !UpperL.hasValue())
    729     UpperU = UpperL = true;
    730   else if (UpperU.hasValue() && !UpperL.hasValue())
    731     UpperL = UpperU;
    732   else if (UpperL.hasValue() && !UpperU.hasValue())
    733     UpperU = UpperL;
    734 
    735   Info.U = *UpperU ? "U" : "u";
    736   Info.L = *UpperL ? "L" : "l";
    737   Info.LL = *UpperL ? "LL" : "ll";
    738   Info.F = UpperF ? "F" : "f";
    739 
    740   Info.Hex = Info.Octal = false;
    741   if (text.startswith("0x"))
    742     Info.Hex = true;
    743   else if (!isFloat && !isIntZero && text.startswith("0"))
    744     Info.Octal = true;
    745 
    746   SourceLocation B = literalRange.getBegin();
    747   Info.WithoutSuffRange =
    748       CharSourceRange::getCharRange(B, B.getLocWithOffset(text.size()));
    749   return true;
    750 }
    751 
    752 static bool rewriteToNumberLiteral(const ObjCMessageExpr *Msg,
    753                                    const NSAPI &NS, Commit &commit) {
    754   if (Msg->getNumArgs() != 1)
    755     return false;
    756 
    757   const Expr *Arg = Msg->getArg(0)->IgnoreParenImpCasts();
    758   if (const CharacterLiteral *CharE = dyn_cast<CharacterLiteral>(Arg))
    759     return rewriteToCharLiteral(Msg, CharE, NS, commit);
    760   if (const ObjCBoolLiteralExpr *BE = dyn_cast<ObjCBoolLiteralExpr>(Arg))
    761     return rewriteToBoolLiteral(Msg, BE, NS, commit);
    762   if (const CXXBoolLiteralExpr *BE = dyn_cast<CXXBoolLiteralExpr>(Arg))
    763     return rewriteToBoolLiteral(Msg, BE, NS, commit);
    764 
    765   const Expr *literalE = Arg;
    766   if (const UnaryOperator *UOE = dyn_cast<UnaryOperator>(literalE)) {
    767     if (UOE->getOpcode() == UO_Plus || UOE->getOpcode() == UO_Minus)
    768       literalE = UOE->getSubExpr();
    769   }
    770 
    771   // Only integer and floating literals, otherwise try to rewrite to boxed
    772   // expression.
    773   if (!isa<IntegerLiteral>(literalE) && !isa<FloatingLiteral>(literalE))
    774     return rewriteToNumericBoxedExpression(Msg, NS, commit);
    775 
    776   ASTContext &Ctx = NS.getASTContext();
    777   Selector Sel = Msg->getSelector();
    778   Optional<NSAPI::NSNumberLiteralMethodKind>
    779     MKOpt = NS.getNSNumberLiteralMethodKind(Sel);
    780   if (!MKOpt)
    781     return false;
    782   NSAPI::NSNumberLiteralMethodKind MK = *MKOpt;
    783 
    784   bool CallIsUnsigned = false, CallIsLong = false, CallIsLongLong = false;
    785   bool CallIsFloating = false, CallIsDouble = false;
    786 
    787   switch (MK) {
    788   // We cannot have these calls with int/float literals.
    789   case NSAPI::NSNumberWithChar:
    790   case NSAPI::NSNumberWithUnsignedChar:
    791   case NSAPI::NSNumberWithShort:
    792   case NSAPI::NSNumberWithUnsignedShort:
    793   case NSAPI::NSNumberWithBool:
    794     return rewriteToNumericBoxedExpression(Msg, NS, commit);
    795 
    796   case NSAPI::NSNumberWithUnsignedInt:
    797   case NSAPI::NSNumberWithUnsignedInteger:
    798     CallIsUnsigned = true;
    799     LLVM_FALLTHROUGH;
    800   case NSAPI::NSNumberWithInt:
    801   case NSAPI::NSNumberWithInteger:
    802     break;
    803 
    804   case NSAPI::NSNumberWithUnsignedLong:
    805     CallIsUnsigned = true;
    806     LLVM_FALLTHROUGH;
    807   case NSAPI::NSNumberWithLong:
    808     CallIsLong = true;
    809     break;
    810 
    811   case NSAPI::NSNumberWithUnsignedLongLong:
    812     CallIsUnsigned = true;
    813     LLVM_FALLTHROUGH;
    814   case NSAPI::NSNumberWithLongLong:
    815     CallIsLongLong = true;
    816     break;
    817 
    818   case NSAPI::NSNumberWithDouble:
    819     CallIsDouble = true;
    820     LLVM_FALLTHROUGH;
    821   case NSAPI::NSNumberWithFloat:
    822     CallIsFloating = true;
    823     break;
    824   }
    825 
    826   SourceRange ArgRange = Arg->getSourceRange();
    827   QualType ArgTy = Arg->getType();
    828   QualType CallTy = Msg->getArg(0)->getType();
    829 
    830   // Check for the easy case, the literal maps directly to the call.
    831   if (Ctx.hasSameType(ArgTy, CallTy)) {
    832     commit.replaceWithInner(Msg->getSourceRange(), ArgRange);
    833     commit.insert(ArgRange.getBegin(), "@");
    834     return true;
    835   }
    836 
    837   // We will need to modify the literal suffix to get the same type as the call.
    838   // Try with boxed expression if it came from a macro.
    839   if (ArgRange.getBegin().isMacroID())
    840     return rewriteToNumericBoxedExpression(Msg, NS, commit);
    841 
    842   bool LitIsFloat = ArgTy->isFloatingType();
    843   // For a float passed to integer call, don't try rewriting to objc literal.
    844   // It is difficult and a very uncommon case anyway.
    845   // But try with boxed expression.
    846   if (LitIsFloat && !CallIsFloating)
    847     return rewriteToNumericBoxedExpression(Msg, NS, commit);
    848 
    849   // Try to modify the literal make it the same type as the method call.
    850   // -Modify the suffix, and/or
    851   // -Change integer to float
    852 
    853   LiteralInfo LitInfo;
    854   bool isIntZero = false;
    855   if (const IntegerLiteral *IntE = dyn_cast<IntegerLiteral>(literalE))
    856     isIntZero = !IntE->getValue().getBoolValue();
    857   if (!getLiteralInfo(ArgRange, LitIsFloat, isIntZero, Ctx, LitInfo))
    858     return rewriteToNumericBoxedExpression(Msg, NS, commit);
    859 
    860   // Not easy to do int -> float with hex/octal and uncommon anyway.
    861   if (!LitIsFloat && CallIsFloating && (LitInfo.Hex || LitInfo.Octal))
    862     return rewriteToNumericBoxedExpression(Msg, NS, commit);
    863 
    864   SourceLocation LitB = LitInfo.WithoutSuffRange.getBegin();
    865   SourceLocation LitE = LitInfo.WithoutSuffRange.getEnd();
    866 
    867   commit.replaceWithInner(CharSourceRange::getTokenRange(Msg->getSourceRange()),
    868                          LitInfo.WithoutSuffRange);
    869   commit.insert(LitB, "@");
    870 
    871   if (!LitIsFloat && CallIsFloating)
    872     commit.insert(LitE, ".0");
    873 
    874   if (CallIsFloating) {
    875     if (!CallIsDouble)
    876       commit.insert(LitE, LitInfo.F);
    877   } else {
    878     if (CallIsUnsigned)
    879       commit.insert(LitE, LitInfo.U);
    880 
    881     if (CallIsLong)
    882       commit.insert(LitE, LitInfo.L);
    883     else if (CallIsLongLong)
    884       commit.insert(LitE, LitInfo.LL);
    885   }
    886   return true;
    887 }
    888 
    889 // FIXME: Make determination of operator precedence more general and
    890 // make it broadly available.
    891 static bool subscriptOperatorNeedsParens(const Expr *FullExpr) {
    892   const Expr* Expr = FullExpr->IgnoreImpCasts();
    893   if (isa<ArraySubscriptExpr>(Expr) ||
    894       isa<CallExpr>(Expr) ||
    895       isa<DeclRefExpr>(Expr) ||
    896       isa<CXXNamedCastExpr>(Expr) ||
    897       isa<CXXConstructExpr>(Expr) ||
    898       isa<CXXThisExpr>(Expr) ||
    899       isa<CXXTypeidExpr>(Expr) ||
    900       isa<CXXUnresolvedConstructExpr>(Expr) ||
    901       isa<ObjCMessageExpr>(Expr) ||
    902       isa<ObjCPropertyRefExpr>(Expr) ||
    903       isa<ObjCProtocolExpr>(Expr) ||
    904       isa<MemberExpr>(Expr) ||
    905       isa<ObjCIvarRefExpr>(Expr) ||
    906       isa<ParenExpr>(FullExpr) ||
    907       isa<ParenListExpr>(Expr) ||
    908       isa<SizeOfPackExpr>(Expr))
    909     return false;
    910 
    911   return true;
    912 }
    913 static bool castOperatorNeedsParens(const Expr *FullExpr) {
    914   const Expr* Expr = FullExpr->IgnoreImpCasts();
    915   if (isa<ArraySubscriptExpr>(Expr) ||
    916       isa<CallExpr>(Expr) ||
    917       isa<DeclRefExpr>(Expr) ||
    918       isa<CastExpr>(Expr) ||
    919       isa<CXXNewExpr>(Expr) ||
    920       isa<CXXConstructExpr>(Expr) ||
    921       isa<CXXDeleteExpr>(Expr) ||
    922       isa<CXXNoexceptExpr>(Expr) ||
    923       isa<CXXPseudoDestructorExpr>(Expr) ||
    924       isa<CXXScalarValueInitExpr>(Expr) ||
    925       isa<CXXThisExpr>(Expr) ||
    926       isa<CXXTypeidExpr>(Expr) ||
    927       isa<CXXUnresolvedConstructExpr>(Expr) ||
    928       isa<ObjCMessageExpr>(Expr) ||
    929       isa<ObjCPropertyRefExpr>(Expr) ||
    930       isa<ObjCProtocolExpr>(Expr) ||
    931       isa<MemberExpr>(Expr) ||
    932       isa<ObjCIvarRefExpr>(Expr) ||
    933       isa<ParenExpr>(FullExpr) ||
    934       isa<ParenListExpr>(Expr) ||
    935       isa<SizeOfPackExpr>(Expr) ||
    936       isa<UnaryOperator>(Expr))
    937     return false;
    938 
    939   return true;
    940 }
    941 
    942 static void objectifyExpr(const Expr *E, Commit &commit) {
    943   if (!E) return;
    944 
    945   QualType T = E->getType();
    946   if (T->isObjCObjectPointerType()) {
    947     if (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E)) {
    948       if (ICE->getCastKind() != CK_CPointerToObjCPointerCast)
    949         return;
    950     } else {
    951       return;
    952     }
    953   } else if (!T->isPointerType()) {
    954     return;
    955   }
    956 
    957   SourceRange Range = E->getSourceRange();
    958   if (castOperatorNeedsParens(E))
    959     commit.insertWrap("(", Range, ")");
    960   commit.insertBefore(Range.getBegin(), "(id)");
    961 }
    962 
    963 //===----------------------------------------------------------------------===//
    964 // rewriteToNumericBoxedExpression.
    965 //===----------------------------------------------------------------------===//
    966 
    967 static bool isEnumConstant(const Expr *E) {
    968   if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E->IgnoreParenImpCasts()))
    969     if (const ValueDecl *VD = DRE->getDecl())
    970       return isa<EnumConstantDecl>(VD);
    971 
    972   return false;
    973 }
    974 
    975 static bool rewriteToNumericBoxedExpression(const ObjCMessageExpr *Msg,
    976                                             const NSAPI &NS, Commit &commit) {
    977   if (Msg->getNumArgs() != 1)
    978     return false;
    979 
    980   const Expr *Arg = Msg->getArg(0);
    981   if (Arg->isTypeDependent())
    982     return false;
    983 
    984   ASTContext &Ctx = NS.getASTContext();
    985   Selector Sel = Msg->getSelector();
    986   Optional<NSAPI::NSNumberLiteralMethodKind>
    987     MKOpt = NS.getNSNumberLiteralMethodKind(Sel);
    988   if (!MKOpt)
    989     return false;
    990   NSAPI::NSNumberLiteralMethodKind MK = *MKOpt;
    991 
    992   const Expr *OrigArg = Arg->IgnoreImpCasts();
    993   QualType FinalTy = Arg->getType();
    994   QualType OrigTy = OrigArg->getType();
    995   uint64_t FinalTySize = Ctx.getTypeSize(FinalTy);
    996   uint64_t OrigTySize = Ctx.getTypeSize(OrigTy);
    997 
    998   bool isTruncated = FinalTySize < OrigTySize;
    999   bool needsCast = false;
   1000 
   1001   if (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(Arg)) {
   1002     switch (ICE->getCastKind()) {
   1003     case CK_LValueToRValue:
   1004     case CK_NoOp:
   1005     case CK_UserDefinedConversion:
   1006       break;
   1007 
   1008     case CK_IntegralCast: {
   1009       if (MK == NSAPI::NSNumberWithBool && OrigTy->isBooleanType())
   1010         break;
   1011       // Be more liberal with Integer/UnsignedInteger which are very commonly
   1012       // used.
   1013       if ((MK == NSAPI::NSNumberWithInteger ||
   1014            MK == NSAPI::NSNumberWithUnsignedInteger) &&
   1015           !isTruncated) {
   1016         if (OrigTy->getAs<EnumType>() || isEnumConstant(OrigArg))
   1017           break;
   1018         if ((MK==NSAPI::NSNumberWithInteger) == OrigTy->isSignedIntegerType() &&
   1019             OrigTySize >= Ctx.getTypeSize(Ctx.IntTy))
   1020           break;
   1021       }
   1022 
   1023       needsCast = true;
   1024       break;
   1025     }
   1026 
   1027     case CK_PointerToBoolean:
   1028     case CK_IntegralToBoolean:
   1029     case CK_IntegralToFloating:
   1030     case CK_FloatingToIntegral:
   1031     case CK_FloatingToBoolean:
   1032     case CK_FloatingCast:
   1033     case CK_FloatingComplexToReal:
   1034     case CK_FloatingComplexToBoolean:
   1035     case CK_IntegralComplexToReal:
   1036     case CK_IntegralComplexToBoolean:
   1037     case CK_AtomicToNonAtomic:
   1038     case CK_AddressSpaceConversion:
   1039       needsCast = true;
   1040       break;
   1041 
   1042     case CK_Dependent:
   1043     case CK_BitCast:
   1044     case CK_LValueBitCast:
   1045     case CK_LValueToRValueBitCast:
   1046     case CK_BaseToDerived:
   1047     case CK_DerivedToBase:
   1048     case CK_UncheckedDerivedToBase:
   1049     case CK_Dynamic:
   1050     case CK_ToUnion:
   1051     case CK_ArrayToPointerDecay:
   1052     case CK_FunctionToPointerDecay:
   1053     case CK_NullToPointer:
   1054     case CK_NullToMemberPointer:
   1055     case CK_BaseToDerivedMemberPointer:
   1056     case CK_DerivedToBaseMemberPointer:
   1057     case CK_MemberPointerToBoolean:
   1058     case CK_ReinterpretMemberPointer:
   1059     case CK_ConstructorConversion:
   1060     case CK_IntegralToPointer:
   1061     case CK_PointerToIntegral:
   1062     case CK_ToVoid:
   1063     case CK_VectorSplat:
   1064     case CK_CPointerToObjCPointerCast:
   1065     case CK_BlockPointerToObjCPointerCast:
   1066     case CK_AnyPointerToBlockPointerCast:
   1067     case CK_ObjCObjectLValueCast:
   1068     case CK_FloatingRealToComplex:
   1069     case CK_FloatingComplexCast:
   1070     case CK_FloatingComplexToIntegralComplex:
   1071     case CK_IntegralRealToComplex:
   1072     case CK_IntegralComplexCast:
   1073     case CK_IntegralComplexToFloatingComplex:
   1074     case CK_ARCProduceObject:
   1075     case CK_ARCConsumeObject:
   1076     case CK_ARCReclaimReturnedObject:
   1077     case CK_ARCExtendBlockObject:
   1078     case CK_NonAtomicToAtomic:
   1079     case CK_CopyAndAutoreleaseBlockObject:
   1080     case CK_BuiltinFnToFnPtr:
   1081     case CK_ZeroToOCLOpaqueType:
   1082     case CK_IntToOCLSampler:
   1083     case CK_MatrixCast:
   1084       return false;
   1085 
   1086     case CK_BooleanToSignedIntegral:
   1087       llvm_unreachable("OpenCL-specific cast in Objective-C?");
   1088 
   1089     case CK_FloatingToFixedPoint:
   1090     case CK_FixedPointToFloating:
   1091     case CK_FixedPointCast:
   1092     case CK_FixedPointToBoolean:
   1093     case CK_FixedPointToIntegral:
   1094     case CK_IntegralToFixedPoint:
   1095       llvm_unreachable("Fixed point types are disabled for Objective-C");
   1096     }
   1097   }
   1098 
   1099   if (needsCast) {
   1100     DiagnosticsEngine &Diags = Ctx.getDiagnostics();
   1101     // FIXME: Use a custom category name to distinguish migration diagnostics.
   1102     unsigned diagID = Diags.getCustomDiagID(DiagnosticsEngine::Warning,
   1103                        "converting to boxing syntax requires casting %0 to %1");
   1104     Diags.Report(Msg->getExprLoc(), diagID) << OrigTy << FinalTy
   1105         << Msg->getSourceRange();
   1106     return false;
   1107   }
   1108 
   1109   SourceRange ArgRange = OrigArg->getSourceRange();
   1110   commit.replaceWithInner(Msg->getSourceRange(), ArgRange);
   1111 
   1112   if (isa<ParenExpr>(OrigArg) || isa<IntegerLiteral>(OrigArg))
   1113     commit.insertBefore(ArgRange.getBegin(), "@");
   1114   else
   1115     commit.insertWrap("@(", ArgRange, ")");
   1116 
   1117   return true;
   1118 }
   1119 
   1120 //===----------------------------------------------------------------------===//
   1121 // rewriteToStringBoxedExpression.
   1122 //===----------------------------------------------------------------------===//
   1123 
   1124 static bool doRewriteToUTF8StringBoxedExpressionHelper(
   1125                                               const ObjCMessageExpr *Msg,
   1126                                               const NSAPI &NS, Commit &commit) {
   1127   const Expr *Arg = Msg->getArg(0);
   1128   if (Arg->isTypeDependent())
   1129     return false;
   1130 
   1131   ASTContext &Ctx = NS.getASTContext();
   1132 
   1133   const Expr *OrigArg = Arg->IgnoreImpCasts();
   1134   QualType OrigTy = OrigArg->getType();
   1135   if (OrigTy->isArrayType())
   1136     OrigTy = Ctx.getArrayDecayedType(OrigTy);
   1137 
   1138   if (const StringLiteral *
   1139         StrE = dyn_cast<StringLiteral>(OrigArg->IgnoreParens())) {
   1140     commit.replaceWithInner(Msg->getSourceRange(), StrE->getSourceRange());
   1141     commit.insert(StrE->getBeginLoc(), "@");
   1142     return true;
   1143   }
   1144 
   1145   if (const PointerType *PT = OrigTy->getAs<PointerType>()) {
   1146     QualType PointeeType = PT->getPointeeType();
   1147     if (Ctx.hasSameUnqualifiedType(PointeeType, Ctx.CharTy)) {
   1148       SourceRange ArgRange = OrigArg->getSourceRange();
   1149       commit.replaceWithInner(Msg->getSourceRange(), ArgRange);
   1150 
   1151       if (isa<ParenExpr>(OrigArg) || isa<IntegerLiteral>(OrigArg))
   1152         commit.insertBefore(ArgRange.getBegin(), "@");
   1153       else
   1154         commit.insertWrap("@(", ArgRange, ")");
   1155 
   1156       return true;
   1157     }
   1158   }
   1159 
   1160   return false;
   1161 }
   1162 
   1163 static bool rewriteToStringBoxedExpression(const ObjCMessageExpr *Msg,
   1164                                            const NSAPI &NS, Commit &commit) {
   1165   Selector Sel = Msg->getSelector();
   1166 
   1167   if (Sel == NS.getNSStringSelector(NSAPI::NSStr_stringWithUTF8String) ||
   1168       Sel == NS.getNSStringSelector(NSAPI::NSStr_stringWithCString) ||
   1169       Sel == NS.getNSStringSelector(NSAPI::NSStr_initWithUTF8String)) {
   1170     if (Msg->getNumArgs() != 1)
   1171       return false;
   1172     return doRewriteToUTF8StringBoxedExpressionHelper(Msg, NS, commit);
   1173   }
   1174 
   1175   if (Sel == NS.getNSStringSelector(NSAPI::NSStr_stringWithCStringEncoding)) {
   1176     if (Msg->getNumArgs() != 2)
   1177       return false;
   1178 
   1179     const Expr *encodingArg = Msg->getArg(1);
   1180     if (NS.isNSUTF8StringEncodingConstant(encodingArg) ||
   1181         NS.isNSASCIIStringEncodingConstant(encodingArg))
   1182       return doRewriteToUTF8StringBoxedExpressionHelper(Msg, NS, commit);
   1183   }
   1184 
   1185   return false;
   1186 }
   1187