Revert "[NFC, Refactor] Modernize StorageClass from Specifiers.h to a scoped enum...
[lldb.git] / clang / lib / Frontend / Rewrite / RewriteModernObjC.cpp
1 //===-- RewriteModernObjC.cpp - Playground for the code 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 // Hacks and fun related to the code rewriter.
10 //
11 //===----------------------------------------------------------------------===//
12
13 #include "clang/Rewrite/Frontend/ASTConsumers.h"
14 #include "clang/AST/AST.h"
15 #include "clang/AST/ASTConsumer.h"
16 #include "clang/AST/Attr.h"
17 #include "clang/AST/ParentMap.h"
18 #include "clang/Basic/CharInfo.h"
19 #include "clang/Basic/Diagnostic.h"
20 #include "clang/Basic/IdentifierTable.h"
21 #include "clang/Basic/SourceManager.h"
22 #include "clang/Basic/TargetInfo.h"
23 #include "clang/Config/config.h"
24 #include "clang/Lex/Lexer.h"
25 #include "clang/Rewrite/Core/Rewriter.h"
26 #include "llvm/ADT/DenseSet.h"
27 #include "llvm/ADT/SmallPtrSet.h"
28 #include "llvm/ADT/StringExtras.h"
29 #include "llvm/Support/MemoryBuffer.h"
30 #include "llvm/Support/raw_ostream.h"
31 #include <memory>
32
33 #if CLANG_ENABLE_OBJC_REWRITER
34
35 using namespace clang;
36 using llvm::utostr;
37
38 namespace {
39   class RewriteModernObjC : public ASTConsumer {
40   protected:
41
42     enum {
43       BLOCK_FIELD_IS_OBJECT   =  3,  /* id, NSObject, __attribute__((NSObject)),
44                                         block, ... */
45       BLOCK_FIELD_IS_BLOCK    =  7,  /* a block variable */
46       BLOCK_FIELD_IS_BYREF    =  8,  /* the on stack structure holding the
47                                         __block variable */
48       BLOCK_FIELD_IS_WEAK     = 16,  /* declared __weak, only used in byref copy
49                                         helpers */
50       BLOCK_BYREF_CALLER      = 128, /* called from __block (byref) copy/dispose
51                                         support routines */
52       BLOCK_BYREF_CURRENT_MAX = 256
53     };
54
55     enum {
56       BLOCK_NEEDS_FREE =        (1 << 24),
57       BLOCK_HAS_COPY_DISPOSE =  (1 << 25),
58       BLOCK_HAS_CXX_OBJ =       (1 << 26),
59       BLOCK_IS_GC =             (1 << 27),
60       BLOCK_IS_GLOBAL =         (1 << 28),
61       BLOCK_HAS_DESCRIPTOR =    (1 << 29)
62     };
63
64     Rewriter Rewrite;
65     DiagnosticsEngine &Diags;
66     const LangOptions &LangOpts;
67     ASTContext *Context;
68     SourceManager *SM;
69     TranslationUnitDecl *TUDecl;
70     FileID MainFileID;
71     const char *MainFileStart, *MainFileEnd;
72     Stmt *CurrentBody;
73     ParentMap *PropParentMap; // created lazily.
74     std::string InFileName;
75     std::unique_ptr<raw_ostream> OutFile;
76     std::string Preamble;
77
78     TypeDecl *ProtocolTypeDecl;
79     VarDecl *GlobalVarDecl;
80     Expr *GlobalConstructionExp;
81     unsigned RewriteFailedDiag;
82     unsigned GlobalBlockRewriteFailedDiag;
83     // ObjC string constant support.
84     unsigned NumObjCStringLiterals;
85     VarDecl *ConstantStringClassReference;
86     RecordDecl *NSStringRecord;
87
88     // ObjC foreach break/continue generation support.
89     int BcLabelCount;
90
91     unsigned TryFinallyContainsReturnDiag;
92     // Needed for super.
93     ObjCMethodDecl *CurMethodDef;
94     RecordDecl *SuperStructDecl;
95     RecordDecl *ConstantStringDecl;
96
97     FunctionDecl *MsgSendFunctionDecl;
98     FunctionDecl *MsgSendSuperFunctionDecl;
99     FunctionDecl *MsgSendStretFunctionDecl;
100     FunctionDecl *MsgSendSuperStretFunctionDecl;
101     FunctionDecl *MsgSendFpretFunctionDecl;
102     FunctionDecl *GetClassFunctionDecl;
103     FunctionDecl *GetMetaClassFunctionDecl;
104     FunctionDecl *GetSuperClassFunctionDecl;
105     FunctionDecl *SelGetUidFunctionDecl;
106     FunctionDecl *CFStringFunctionDecl;
107     FunctionDecl *SuperConstructorFunctionDecl;
108     FunctionDecl *CurFunctionDef;
109
110     /* Misc. containers needed for meta-data rewrite. */
111     SmallVector<ObjCImplementationDecl *, 8> ClassImplementation;
112     SmallVector<ObjCCategoryImplDecl *, 8> CategoryImplementation;
113     llvm::SmallPtrSet<ObjCInterfaceDecl*, 8> ObjCSynthesizedStructs;
114     llvm::SmallPtrSet<ObjCProtocolDecl*, 8> ObjCSynthesizedProtocols;
115     llvm::SmallPtrSet<ObjCInterfaceDecl*, 8> ObjCWrittenInterfaces;
116     llvm::SmallPtrSet<TagDecl*, 32> GlobalDefinedTags;
117     SmallVector<ObjCInterfaceDecl*, 32> ObjCInterfacesSeen;
118     /// DefinedNonLazyClasses - List of defined "non-lazy" classes.
119     SmallVector<ObjCInterfaceDecl*, 8> DefinedNonLazyClasses;
120
121     /// DefinedNonLazyCategories - List of defined "non-lazy" categories.
122     SmallVector<ObjCCategoryDecl *, 8> DefinedNonLazyCategories;
123
124     SmallVector<Stmt *, 32> Stmts;
125     SmallVector<int, 8> ObjCBcLabelNo;
126     // Remember all the @protocol(<expr>) expressions.
127     llvm::SmallPtrSet<ObjCProtocolDecl *, 32> ProtocolExprDecls;
128
129     llvm::DenseSet<uint64_t> CopyDestroyCache;
130
131     // Block expressions.
132     SmallVector<BlockExpr *, 32> Blocks;
133     SmallVector<int, 32> InnerDeclRefsCount;
134     SmallVector<DeclRefExpr *, 32> InnerDeclRefs;
135
136     SmallVector<DeclRefExpr *, 32> BlockDeclRefs;
137
138     // Block related declarations.
139     SmallVector<ValueDecl *, 8> BlockByCopyDecls;
140     llvm::SmallPtrSet<ValueDecl *, 8> BlockByCopyDeclsPtrSet;
141     SmallVector<ValueDecl *, 8> BlockByRefDecls;
142     llvm::SmallPtrSet<ValueDecl *, 8> BlockByRefDeclsPtrSet;
143     llvm::DenseMap<ValueDecl *, unsigned> BlockByRefDeclNo;
144     llvm::SmallPtrSet<ValueDecl *, 8> ImportedBlockDecls;
145     llvm::SmallPtrSet<VarDecl *, 8> ImportedLocalExternalDecls;
146
147     llvm::DenseMap<BlockExpr *, std::string> RewrittenBlockExprs;
148     llvm::DenseMap<ObjCInterfaceDecl *,
149                     llvm::SmallSetVector<ObjCIvarDecl *, 8> > ReferencedIvars;
150
151     // ivar bitfield grouping containers
152     llvm::DenseSet<const ObjCInterfaceDecl *> ObjCInterefaceHasBitfieldGroups;
153     llvm::DenseMap<const ObjCIvarDecl* , unsigned> IvarGroupNumber;
154     // This container maps an <class, group number for ivar> tuple to the type
155     // of the struct where the bitfield belongs.
156     llvm::DenseMap<std::pair<const ObjCInterfaceDecl*, unsigned>, QualType> GroupRecordType;
157     SmallVector<FunctionDecl*, 32> FunctionDefinitionsSeen;
158
159     // This maps an original source AST to it's rewritten form. This allows
160     // us to avoid rewriting the same node twice (which is very uncommon).
161     // This is needed to support some of the exotic property rewriting.
162     llvm::DenseMap<Stmt *, Stmt *> ReplacedNodes;
163
164     // Needed for header files being rewritten
165     bool IsHeader;
166     bool SilenceRewriteMacroWarning;
167     bool GenerateLineInfo;
168     bool objc_impl_method;
169
170     bool DisableReplaceStmt;
171     class DisableReplaceStmtScope {
172       RewriteModernObjC &R;
173       bool SavedValue;
174
175     public:
176       DisableReplaceStmtScope(RewriteModernObjC &R)
177         : R(R), SavedValue(R.DisableReplaceStmt) {
178         R.DisableReplaceStmt = true;
179       }
180       ~DisableReplaceStmtScope() {
181         R.DisableReplaceStmt = SavedValue;
182       }
183     };
184     void InitializeCommon(ASTContext &context);
185
186   public:
187     llvm::DenseMap<ObjCMethodDecl*, std::string> MethodInternalNames;
188
189     // Top Level Driver code.
190     bool HandleTopLevelDecl(DeclGroupRef D) override {
191       for (DeclGroupRef::iterator I = D.begin(), E = D.end(); I != E; ++I) {
192         if (ObjCInterfaceDecl *Class = dyn_cast<ObjCInterfaceDecl>(*I)) {
193           if (!Class->isThisDeclarationADefinition()) {
194             RewriteForwardClassDecl(D);
195             break;
196           } else {
197             // Keep track of all interface declarations seen.
198             ObjCInterfacesSeen.push_back(Class);
199             break;
200           }
201         }
202
203         if (ObjCProtocolDecl *Proto = dyn_cast<ObjCProtocolDecl>(*I)) {
204           if (!Proto->isThisDeclarationADefinition()) {
205             RewriteForwardProtocolDecl(D);
206             break;
207           }
208         }
209
210         if (FunctionDecl *FDecl = dyn_cast<FunctionDecl>(*I)) {
211           // Under modern abi, we cannot translate body of the function
212           // yet until all class extensions and its implementation is seen.
213           // This is because they may introduce new bitfields which must go
214           // into their grouping struct.
215           if (FDecl->isThisDeclarationADefinition() &&
216               // Not c functions defined inside an objc container.
217               !FDecl->isTopLevelDeclInObjCContainer()) {
218             FunctionDefinitionsSeen.push_back(FDecl);
219             break;
220           }
221         }
222         HandleTopLevelSingleDecl(*I);
223       }
224       return true;
225     }
226
227     void HandleTopLevelDeclInObjCContainer(DeclGroupRef D) override {
228       for (DeclGroupRef::iterator I = D.begin(), E = D.end(); I != E; ++I) {
229         if (TypedefNameDecl *TD = dyn_cast<TypedefNameDecl>(*I)) {
230           if (isTopLevelBlockPointerType(TD->getUnderlyingType()))
231             RewriteBlockPointerDecl(TD);
232           else if (TD->getUnderlyingType()->isFunctionPointerType())
233             CheckFunctionPointerDecl(TD->getUnderlyingType(), TD);
234           else
235             RewriteObjCQualifiedInterfaceTypes(TD);
236         }
237       }
238     }
239
240     void HandleTopLevelSingleDecl(Decl *D);
241     void HandleDeclInMainFile(Decl *D);
242     RewriteModernObjC(std::string inFile, std::unique_ptr<raw_ostream> OS,
243                       DiagnosticsEngine &D, const LangOptions &LOpts,
244                       bool silenceMacroWarn, bool LineInfo);
245
246     ~RewriteModernObjC() override {}
247
248     void HandleTranslationUnit(ASTContext &C) override;
249
250     void ReplaceStmt(Stmt *Old, Stmt *New) {
251       ReplaceStmtWithRange(Old, New, Old->getSourceRange());
252     }
253
254     void ReplaceStmtWithRange(Stmt *Old, Stmt *New, SourceRange SrcRange) {
255       assert(Old != nullptr && New != nullptr && "Expected non-null Stmt's");
256
257       Stmt *ReplacingStmt = ReplacedNodes[Old];
258       if (ReplacingStmt)
259         return; // We can't rewrite the same node twice.
260
261       if (DisableReplaceStmt)
262         return;
263
264       // Measure the old text.
265       int Size = Rewrite.getRangeSize(SrcRange);
266       if (Size == -1) {
267         Diags.Report(Context->getFullLoc(Old->getBeginLoc()), RewriteFailedDiag)
268             << Old->getSourceRange();
269         return;
270       }
271       // Get the new text.
272       std::string SStr;
273       llvm::raw_string_ostream S(SStr);
274       New->printPretty(S, nullptr, PrintingPolicy(LangOpts));
275       const std::string &Str = S.str();
276
277       // If replacement succeeded or warning disabled return with no warning.
278       if (!Rewrite.ReplaceText(SrcRange.getBegin(), Size, Str)) {
279         ReplacedNodes[Old] = New;
280         return;
281       }
282       if (SilenceRewriteMacroWarning)
283         return;
284       Diags.Report(Context->getFullLoc(Old->getBeginLoc()), RewriteFailedDiag)
285           << Old->getSourceRange();
286     }
287
288     void InsertText(SourceLocation Loc, StringRef Str,
289                     bool InsertAfter = true) {
290       // If insertion succeeded or warning disabled return with no warning.
291       if (!Rewrite.InsertText(Loc, Str, InsertAfter) ||
292           SilenceRewriteMacroWarning)
293         return;
294
295       Diags.Report(Context->getFullLoc(Loc), RewriteFailedDiag);
296     }
297
298     void ReplaceText(SourceLocation Start, unsigned OrigLength,
299                      StringRef Str) {
300       // If removal succeeded or warning disabled return with no warning.
301       if (!Rewrite.ReplaceText(Start, OrigLength, Str) ||
302           SilenceRewriteMacroWarning)
303         return;
304
305       Diags.Report(Context->getFullLoc(Start), RewriteFailedDiag);
306     }
307
308     // Syntactic Rewriting.
309     void RewriteRecordBody(RecordDecl *RD);
310     void RewriteInclude();
311     void RewriteLineDirective(const Decl *D);
312     void ConvertSourceLocationToLineDirective(SourceLocation Loc,
313                                               std::string &LineString);
314     void RewriteForwardClassDecl(DeclGroupRef D);
315     void RewriteForwardClassDecl(const SmallVectorImpl<Decl *> &DG);
316     void RewriteForwardClassEpilogue(ObjCInterfaceDecl *ClassDecl,
317                                      const std::string &typedefString);
318     void RewriteImplementations();
319     void RewritePropertyImplDecl(ObjCPropertyImplDecl *PID,
320                                  ObjCImplementationDecl *IMD,
321                                  ObjCCategoryImplDecl *CID);
322     void RewriteInterfaceDecl(ObjCInterfaceDecl *Dcl);
323     void RewriteImplementationDecl(Decl *Dcl);
324     void RewriteObjCMethodDecl(const ObjCInterfaceDecl *IDecl,
325                                ObjCMethodDecl *MDecl, std::string &ResultStr);
326     void RewriteTypeIntoString(QualType T, std::string &ResultStr,
327                                const FunctionType *&FPRetType);
328     void RewriteByRefString(std::string &ResultStr, const std::string &Name,
329                             ValueDecl *VD, bool def=false);
330     void RewriteCategoryDecl(ObjCCategoryDecl *Dcl);
331     void RewriteProtocolDecl(ObjCProtocolDecl *Dcl);
332     void RewriteForwardProtocolDecl(DeclGroupRef D);
333     void RewriteForwardProtocolDecl(const SmallVectorImpl<Decl *> &DG);
334     void RewriteMethodDeclaration(ObjCMethodDecl *Method);
335     void RewriteProperty(ObjCPropertyDecl *prop);
336     void RewriteFunctionDecl(FunctionDecl *FD);
337     void RewriteBlockPointerType(std::string& Str, QualType Type);
338     void RewriteBlockPointerTypeVariable(std::string& Str, ValueDecl *VD);
339     void RewriteBlockLiteralFunctionDecl(FunctionDecl *FD);
340     void RewriteObjCQualifiedInterfaceTypes(Decl *Dcl);
341     void RewriteTypeOfDecl(VarDecl *VD);
342     void RewriteObjCQualifiedInterfaceTypes(Expr *E);
343
344     std::string getIvarAccessString(ObjCIvarDecl *D);
345
346     // Expression Rewriting.
347     Stmt *RewriteFunctionBodyOrGlobalInitializer(Stmt *S);
348     Stmt *RewriteAtEncode(ObjCEncodeExpr *Exp);
349     Stmt *RewritePropertyOrImplicitGetter(PseudoObjectExpr *Pseudo);
350     Stmt *RewritePropertyOrImplicitSetter(PseudoObjectExpr *Pseudo);
351     Stmt *RewriteAtSelector(ObjCSelectorExpr *Exp);
352     Stmt *RewriteMessageExpr(ObjCMessageExpr *Exp);
353     Stmt *RewriteObjCStringLiteral(ObjCStringLiteral *Exp);
354     Stmt *RewriteObjCBoolLiteralExpr(ObjCBoolLiteralExpr *Exp);
355     Stmt *RewriteObjCBoxedExpr(ObjCBoxedExpr *Exp);
356     Stmt *RewriteObjCArrayLiteralExpr(ObjCArrayLiteral *Exp);
357     Stmt *RewriteObjCDictionaryLiteralExpr(ObjCDictionaryLiteral *Exp);
358     Stmt *RewriteObjCProtocolExpr(ObjCProtocolExpr *Exp);
359     Stmt *RewriteObjCTryStmt(ObjCAtTryStmt *S);
360     Stmt *RewriteObjCAutoreleasePoolStmt(ObjCAutoreleasePoolStmt  *S);
361     Stmt *RewriteObjCSynchronizedStmt(ObjCAtSynchronizedStmt *S);
362     Stmt *RewriteObjCThrowStmt(ObjCAtThrowStmt *S);
363     Stmt *RewriteObjCForCollectionStmt(ObjCForCollectionStmt *S,
364                                        SourceLocation OrigEnd);
365     Stmt *RewriteBreakStmt(BreakStmt *S);
366     Stmt *RewriteContinueStmt(ContinueStmt *S);
367     void RewriteCastExpr(CStyleCastExpr *CE);
368     void RewriteImplicitCastObjCExpr(CastExpr *IE);
369
370     // Computes ivar bitfield group no.
371     unsigned ObjCIvarBitfieldGroupNo(ObjCIvarDecl *IV);
372     // Names field decl. for ivar bitfield group.
373     void ObjCIvarBitfieldGroupDecl(ObjCIvarDecl *IV, std::string &Result);
374     // Names struct type for ivar bitfield group.
375     void ObjCIvarBitfieldGroupType(ObjCIvarDecl *IV, std::string &Result);
376     // Names symbol for ivar bitfield group field offset.
377     void ObjCIvarBitfieldGroupOffset(ObjCIvarDecl *IV, std::string &Result);
378     // Given an ivar bitfield, it builds (or finds) its group record type.
379     QualType GetGroupRecordTypeForObjCIvarBitfield(ObjCIvarDecl *IV);
380     QualType SynthesizeBitfieldGroupStructType(
381                                     ObjCIvarDecl *IV,
382                                     SmallVectorImpl<ObjCIvarDecl *> &IVars);
383
384     // Block rewriting.
385     void RewriteBlocksInFunctionProtoType(QualType funcType, NamedDecl *D);
386
387     // Block specific rewrite rules.
388     void RewriteBlockPointerDecl(NamedDecl *VD);
389     void RewriteByRefVar(VarDecl *VD, bool firstDecl, bool lastDecl);
390     Stmt *RewriteBlockDeclRefExpr(DeclRefExpr *VD);
391     Stmt *RewriteLocalVariableExternalStorage(DeclRefExpr *DRE);
392     void RewriteBlockPointerFunctionArgs(FunctionDecl *FD);
393
394     void RewriteObjCInternalStruct(ObjCInterfaceDecl *CDecl,
395                                       std::string &Result);
396
397     void RewriteObjCFieldDecl(FieldDecl *fieldDecl, std::string &Result);
398     bool IsTagDefinedInsideClass(ObjCContainerDecl *IDecl, TagDecl *Tag,
399                                  bool &IsNamedDefinition);
400     void RewriteLocallyDefinedNamedAggregates(FieldDecl *fieldDecl,
401                                               std::string &Result);
402
403     bool RewriteObjCFieldDeclType(QualType &Type, std::string &Result);
404
405     void RewriteIvarOffsetSymbols(ObjCInterfaceDecl *CDecl,
406                                   std::string &Result);
407
408     void Initialize(ASTContext &context) override;
409
410     // Misc. AST transformation routines. Sometimes they end up calling
411     // rewriting routines on the new ASTs.
412     CallExpr *SynthesizeCallToFunctionDecl(FunctionDecl *FD,
413                                            ArrayRef<Expr *> Args,
414                                            SourceLocation StartLoc=SourceLocation(),
415                                            SourceLocation EndLoc=SourceLocation());
416
417     Expr *SynthMsgSendStretCallExpr(FunctionDecl *MsgSendStretFlavor,
418                                         QualType returnType,
419                                         SmallVectorImpl<QualType> &ArgTypes,
420                                         SmallVectorImpl<Expr*> &MsgExprs,
421                                         ObjCMethodDecl *Method);
422
423     Stmt *SynthMessageExpr(ObjCMessageExpr *Exp,
424                            SourceLocation StartLoc=SourceLocation(),
425                            SourceLocation EndLoc=SourceLocation());
426
427     void SynthCountByEnumWithState(std::string &buf);
428     void SynthMsgSendFunctionDecl();
429     void SynthMsgSendSuperFunctionDecl();
430     void SynthMsgSendStretFunctionDecl();
431     void SynthMsgSendFpretFunctionDecl();
432     void SynthMsgSendSuperStretFunctionDecl();
433     void SynthGetClassFunctionDecl();
434     void SynthGetMetaClassFunctionDecl();
435     void SynthGetSuperClassFunctionDecl();
436     void SynthSelGetUidFunctionDecl();
437     void SynthSuperConstructorFunctionDecl();
438
439     // Rewriting metadata
440     template<typename MethodIterator>
441     void RewriteObjCMethodsMetaData(MethodIterator MethodBegin,
442                                     MethodIterator MethodEnd,
443                                     bool IsInstanceMethod,
444                                     StringRef prefix,
445                                     StringRef ClassName,
446                                     std::string &Result);
447     void RewriteObjCProtocolMetaData(ObjCProtocolDecl *Protocol,
448                                      std::string &Result);
449     void RewriteObjCClassMetaData(ObjCImplementationDecl *IDecl,
450                                           std::string &Result);
451     void RewriteClassSetupInitHook(std::string &Result);
452
453     void RewriteMetaDataIntoBuffer(std::string &Result);
454     void WriteImageInfo(std::string &Result);
455     void RewriteObjCCategoryImplDecl(ObjCCategoryImplDecl *CDecl,
456                                              std::string &Result);
457     void RewriteCategorySetupInitHook(std::string &Result);
458
459     // Rewriting ivar
460     void RewriteIvarOffsetComputation(ObjCIvarDecl *ivar,
461                                               std::string &Result);
462     Stmt *RewriteObjCIvarRefExpr(ObjCIvarRefExpr *IV);
463
464
465     std::string SynthesizeByrefCopyDestroyHelper(VarDecl *VD, int flag);
466     std::string SynthesizeBlockHelperFuncs(BlockExpr *CE, int i,
467                                       StringRef funcName, std::string Tag);
468     std::string SynthesizeBlockFunc(BlockExpr *CE, int i,
469                                       StringRef funcName, std::string Tag);
470     std::string SynthesizeBlockImpl(BlockExpr *CE,
471                                     std::string Tag, std::string Desc);
472     std::string SynthesizeBlockDescriptor(std::string DescTag,
473                                           std::string ImplTag,
474                                           int i, StringRef funcName,
475                                           unsigned hasCopy);
476     Stmt *SynthesizeBlockCall(CallExpr *Exp, const Expr* BlockExp);
477     void SynthesizeBlockLiterals(SourceLocation FunLocStart,
478                                  StringRef FunName);
479     FunctionDecl *SynthBlockInitFunctionDecl(StringRef name);
480     Stmt *SynthBlockInitExpr(BlockExpr *Exp,
481                       const SmallVectorImpl<DeclRefExpr *> &InnerBlockDeclRefs);
482
483     // Misc. helper routines.
484     QualType getProtocolType();
485     void WarnAboutReturnGotoStmts(Stmt *S);
486     void CheckFunctionPointerDecl(QualType dType, NamedDecl *ND);
487     void InsertBlockLiteralsWithinFunction(FunctionDecl *FD);
488     void InsertBlockLiteralsWithinMethod(ObjCMethodDecl *MD);
489
490     bool IsDeclStmtInForeachHeader(DeclStmt *DS);
491     void CollectBlockDeclRefInfo(BlockExpr *Exp);
492     void GetBlockDeclRefExprs(Stmt *S);
493     void GetInnerBlockDeclRefExprs(Stmt *S,
494                 SmallVectorImpl<DeclRefExpr *> &InnerBlockDeclRefs,
495                 llvm::SmallPtrSetImpl<const DeclContext *> &InnerContexts);
496
497     // We avoid calling Type::isBlockPointerType(), since it operates on the
498     // canonical type. We only care if the top-level type is a closure pointer.
499     bool isTopLevelBlockPointerType(QualType T) {
500       return isa<BlockPointerType>(T);
501     }
502
503     /// convertBlockPointerToFunctionPointer - Converts a block-pointer type
504     /// to a function pointer type and upon success, returns true; false
505     /// otherwise.
506     bool convertBlockPointerToFunctionPointer(QualType &T) {
507       if (isTopLevelBlockPointerType(T)) {
508         const auto *BPT = T->castAs<BlockPointerType>();
509         T = Context->getPointerType(BPT->getPointeeType());
510         return true;
511       }
512       return false;
513     }
514
515     bool convertObjCTypeToCStyleType(QualType &T);
516
517     bool needToScanForQualifiers(QualType T);
518     QualType getSuperStructType();
519     QualType getConstantStringStructType();
520     QualType convertFunctionTypeOfBlocks(const FunctionType *FT);
521
522     void convertToUnqualifiedObjCType(QualType &T) {
523       if (T->isObjCQualifiedIdType()) {
524         bool isConst = T.isConstQualified();
525         T = isConst ? Context->getObjCIdType().withConst()
526                     : Context->getObjCIdType();
527       }
528       else if (T->isObjCQualifiedClassType())
529         T = Context->getObjCClassType();
530       else if (T->isObjCObjectPointerType() &&
531                T->getPointeeType()->isObjCQualifiedInterfaceType()) {
532         if (const ObjCObjectPointerType * OBJPT =
533               T->getAsObjCInterfacePointerType()) {
534           const ObjCInterfaceType *IFaceT = OBJPT->getInterfaceType();
535           T = QualType(IFaceT, 0);
536           T = Context->getPointerType(T);
537         }
538      }
539     }
540
541     // FIXME: This predicate seems like it would be useful to add to ASTContext.
542     bool isObjCType(QualType T) {
543       if (!LangOpts.ObjC)
544         return false;
545
546       QualType OCT = Context->getCanonicalType(T).getUnqualifiedType();
547
548       if (OCT == Context->getCanonicalType(Context->getObjCIdType()) ||
549           OCT == Context->getCanonicalType(Context->getObjCClassType()))
550         return true;
551
552       if (const PointerType *PT = OCT->getAs<PointerType>()) {
553         if (isa<ObjCInterfaceType>(PT->getPointeeType()) ||
554             PT->getPointeeType()->isObjCQualifiedIdType())
555           return true;
556       }
557       return false;
558     }
559
560     bool PointerTypeTakesAnyBlockArguments(QualType QT);
561     bool PointerTypeTakesAnyObjCQualifiedType(QualType QT);
562     void GetExtentOfArgList(const char *Name, const char *&LParen,
563                             const char *&RParen);
564
565     void QuoteDoublequotes(std::string &From, std::string &To) {
566       for (unsigned i = 0; i < From.length(); i++) {
567         if (From[i] == '"')
568           To += "\\\"";
569         else
570           To += From[i];
571       }
572     }
573
574     QualType getSimpleFunctionType(QualType result,
575                                    ArrayRef<QualType> args,
576                                    bool variadic = false) {
577       if (result == Context->getObjCInstanceType())
578         result =  Context->getObjCIdType();
579       FunctionProtoType::ExtProtoInfo fpi;
580       fpi.Variadic = variadic;
581       return Context->getFunctionType(result, args, fpi);
582     }
583
584     // Helper function: create a CStyleCastExpr with trivial type source info.
585     CStyleCastExpr* NoTypeInfoCStyleCastExpr(ASTContext *Ctx, QualType Ty,
586                                              CastKind Kind, Expr *E) {
587       TypeSourceInfo *TInfo = Ctx->getTrivialTypeSourceInfo(Ty, SourceLocation());
588       return CStyleCastExpr::Create(*Ctx, Ty, VK_RValue, Kind, E, nullptr,
589                                     FPOptionsOverride(), TInfo,
590                                     SourceLocation(), SourceLocation());
591     }
592
593     bool ImplementationIsNonLazy(const ObjCImplDecl *OD) const {
594       IdentifierInfo* II = &Context->Idents.get("load");
595       Selector LoadSel = Context->Selectors.getSelector(0, &II);
596       return OD->getClassMethod(LoadSel) != nullptr;
597     }
598
599     StringLiteral *getStringLiteral(StringRef Str) {
600       QualType StrType = Context->getConstantArrayType(
601           Context->CharTy, llvm::APInt(32, Str.size() + 1), nullptr,
602           ArrayType::Normal, 0);
603       return StringLiteral::Create(*Context, Str, StringLiteral::Ascii,
604                                    /*Pascal=*/false, StrType, SourceLocation());
605     }
606   };
607 } // end anonymous namespace
608
609 void RewriteModernObjC::RewriteBlocksInFunctionProtoType(QualType funcType,
610                                                    NamedDecl *D) {
611   if (const FunctionProtoType *fproto
612       = dyn_cast<FunctionProtoType>(funcType.IgnoreParens())) {
613     for (const auto &I : fproto->param_types())
614       if (isTopLevelBlockPointerType(I)) {
615         // All the args are checked/rewritten. Don't call twice!
616         RewriteBlockPointerDecl(D);
617         break;
618       }
619   }
620 }
621
622 void RewriteModernObjC::CheckFunctionPointerDecl(QualType funcType, NamedDecl *ND) {
623   const PointerType *PT = funcType->getAs<PointerType>();
624   if (PT && PointerTypeTakesAnyBlockArguments(funcType))
625     RewriteBlocksInFunctionProtoType(PT->getPointeeType(), ND);
626 }
627
628 static bool IsHeaderFile(const std::string &Filename) {
629   std::string::size_type DotPos = Filename.rfind('.');
630
631   if (DotPos == std::string::npos) {
632     // no file extension
633     return false;
634   }
635
636   std::string Ext = std::string(Filename.begin()+DotPos+1, Filename.end());
637   // C header: .h
638   // C++ header: .hh or .H;
639   return Ext == "h" || Ext == "hh" || Ext == "H";
640 }
641
642 RewriteModernObjC::RewriteModernObjC(std::string inFile,
643                                      std::unique_ptr<raw_ostream> OS,
644                                      DiagnosticsEngine &D,
645                                      const LangOptions &LOpts,
646                                      bool silenceMacroWarn, bool LineInfo)
647     : Diags(D), LangOpts(LOpts), InFileName(inFile), OutFile(std::move(OS)),
648       SilenceRewriteMacroWarning(silenceMacroWarn), GenerateLineInfo(LineInfo) {
649   IsHeader = IsHeaderFile(inFile);
650   RewriteFailedDiag = Diags.getCustomDiagID(DiagnosticsEngine::Warning,
651                "rewriting sub-expression within a macro (may not be correct)");
652   // FIXME. This should be an error. But if block is not called, it is OK. And it
653   // may break including some headers.
654   GlobalBlockRewriteFailedDiag = Diags.getCustomDiagID(DiagnosticsEngine::Warning,
655     "rewriting block literal declared in global scope is not implemented");
656
657   TryFinallyContainsReturnDiag = Diags.getCustomDiagID(
658                DiagnosticsEngine::Warning,
659                "rewriter doesn't support user-specified control flow semantics "
660                "for @try/@finally (code may not execute properly)");
661 }
662
663 std::unique_ptr<ASTConsumer> clang::CreateModernObjCRewriter(
664     const std::string &InFile, std::unique_ptr<raw_ostream> OS,
665     DiagnosticsEngine &Diags, const LangOptions &LOpts,
666     bool SilenceRewriteMacroWarning, bool LineInfo) {
667   return std::make_unique<RewriteModernObjC>(InFile, std::move(OS), Diags,
668                                               LOpts, SilenceRewriteMacroWarning,
669                                               LineInfo);
670 }
671
672 void RewriteModernObjC::InitializeCommon(ASTContext &context) {
673   Context = &context;
674   SM = &Context->getSourceManager();
675   TUDecl = Context->getTranslationUnitDecl();
676   MsgSendFunctionDecl = nullptr;
677   MsgSendSuperFunctionDecl = nullptr;
678   MsgSendStretFunctionDecl = nullptr;
679   MsgSendSuperStretFunctionDecl = nullptr;
680   MsgSendFpretFunctionDecl = nullptr;
681   GetClassFunctionDecl = nullptr;
682   GetMetaClassFunctionDecl = nullptr;
683   GetSuperClassFunctionDecl = nullptr;
684   SelGetUidFunctionDecl = nullptr;
685   CFStringFunctionDecl = nullptr;
686   ConstantStringClassReference = nullptr;
687   NSStringRecord = nullptr;
688   CurMethodDef = nullptr;
689   CurFunctionDef = nullptr;
690   GlobalVarDecl = nullptr;
691   GlobalConstructionExp = nullptr;
692   SuperStructDecl = nullptr;
693   ProtocolTypeDecl = nullptr;
694   ConstantStringDecl = nullptr;
695   BcLabelCount = 0;
696   SuperConstructorFunctionDecl = nullptr;
697   NumObjCStringLiterals = 0;
698   PropParentMap = nullptr;
699   CurrentBody = nullptr;
700   DisableReplaceStmt = false;
701   objc_impl_method = false;
702
703   // Get the ID and start/end of the main file.
704   MainFileID = SM->getMainFileID();
705   llvm::MemoryBufferRef MainBuf = SM->getBufferOrFake(MainFileID);
706   MainFileStart = MainBuf.getBufferStart();
707   MainFileEnd = MainBuf.getBufferEnd();
708
709   Rewrite.setSourceMgr(Context->getSourceManager(), Context->getLangOpts());
710 }
711
712 //===----------------------------------------------------------------------===//
713 // Top Level Driver Code
714 //===----------------------------------------------------------------------===//
715
716 void RewriteModernObjC::HandleTopLevelSingleDecl(Decl *D) {
717   if (Diags.hasErrorOccurred())
718     return;
719
720   // Two cases: either the decl could be in the main file, or it could be in a
721   // #included file.  If the former, rewrite it now.  If the later, check to see
722   // if we rewrote the #include/#import.
723   SourceLocation Loc = D->getLocation();
724   Loc = SM->getExpansionLoc(Loc);
725
726   // If this is for a builtin, ignore it.
727   if (Loc.isInvalid()) return;
728
729   // Look for built-in declarations that we need to refer during the rewrite.
730   if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
731     RewriteFunctionDecl(FD);
732   } else if (VarDecl *FVD = dyn_cast<VarDecl>(D)) {
733     // declared in <Foundation/NSString.h>
734     if (FVD->getName() == "_NSConstantStringClassReference") {
735       ConstantStringClassReference = FVD;
736       return;
737     }
738   } else if (ObjCCategoryDecl *CD = dyn_cast<ObjCCategoryDecl>(D)) {
739     RewriteCategoryDecl(CD);
740   } else if (ObjCProtocolDecl *PD = dyn_cast<ObjCProtocolDecl>(D)) {
741     if (PD->isThisDeclarationADefinition())
742       RewriteProtocolDecl(PD);
743   } else if (LinkageSpecDecl *LSD = dyn_cast<LinkageSpecDecl>(D)) {
744     // Recurse into linkage specifications
745     for (DeclContext::decl_iterator DI = LSD->decls_begin(),
746                                  DIEnd = LSD->decls_end();
747          DI != DIEnd; ) {
748       if (ObjCInterfaceDecl *IFace = dyn_cast<ObjCInterfaceDecl>((*DI))) {
749         if (!IFace->isThisDeclarationADefinition()) {
750           SmallVector<Decl *, 8> DG;
751           SourceLocation StartLoc = IFace->getBeginLoc();
752           do {
753             if (isa<ObjCInterfaceDecl>(*DI) &&
754                 !cast<ObjCInterfaceDecl>(*DI)->isThisDeclarationADefinition() &&
755                 StartLoc == (*DI)->getBeginLoc())
756               DG.push_back(*DI);
757             else
758               break;
759
760             ++DI;
761           } while (DI != DIEnd);
762           RewriteForwardClassDecl(DG);
763           continue;
764         }
765         else {
766           // Keep track of all interface declarations seen.
767           ObjCInterfacesSeen.push_back(IFace);
768           ++DI;
769           continue;
770         }
771       }
772
773       if (ObjCProtocolDecl *Proto = dyn_cast<ObjCProtocolDecl>((*DI))) {
774         if (!Proto->isThisDeclarationADefinition()) {
775           SmallVector<Decl *, 8> DG;
776           SourceLocation StartLoc = Proto->getBeginLoc();
777           do {
778             if (isa<ObjCProtocolDecl>(*DI) &&
779                 !cast<ObjCProtocolDecl>(*DI)->isThisDeclarationADefinition() &&
780                 StartLoc == (*DI)->getBeginLoc())
781               DG.push_back(*DI);
782             else
783               break;
784
785             ++DI;
786           } while (DI != DIEnd);
787           RewriteForwardProtocolDecl(DG);
788           continue;
789         }
790       }
791
792       HandleTopLevelSingleDecl(*DI);
793       ++DI;
794     }
795   }
796   // If we have a decl in the main file, see if we should rewrite it.
797   if (SM->isWrittenInMainFile(Loc))
798     return HandleDeclInMainFile(D);
799 }
800
801 //===----------------------------------------------------------------------===//
802 // Syntactic (non-AST) Rewriting Code
803 //===----------------------------------------------------------------------===//
804
805 void RewriteModernObjC::RewriteInclude() {
806   SourceLocation LocStart = SM->getLocForStartOfFile(MainFileID);
807   StringRef MainBuf = SM->getBufferData(MainFileID);
808   const char *MainBufStart = MainBuf.begin();
809   const char *MainBufEnd = MainBuf.end();
810   size_t ImportLen = strlen("import");
811
812   // Loop over the whole file, looking for includes.
813   for (const char *BufPtr = MainBufStart; BufPtr < MainBufEnd; ++BufPtr) {
814     if (*BufPtr == '#') {
815       if (++BufPtr == MainBufEnd)
816         return;
817       while (*BufPtr == ' ' || *BufPtr == '\t')
818         if (++BufPtr == MainBufEnd)
819           return;
820       if (!strncmp(BufPtr, "import", ImportLen)) {
821         // replace import with include
822         SourceLocation ImportLoc =
823           LocStart.getLocWithOffset(BufPtr-MainBufStart);
824         ReplaceText(ImportLoc, ImportLen, "include");
825         BufPtr += ImportLen;
826       }
827     }
828   }
829 }
830
831 static void WriteInternalIvarName(const ObjCInterfaceDecl *IDecl,
832                                   ObjCIvarDecl *IvarDecl, std::string &Result) {
833   Result += "OBJC_IVAR_$_";
834   Result += IDecl->getName();
835   Result += "$";
836   Result += IvarDecl->getName();
837 }
838
839 std::string
840 RewriteModernObjC::getIvarAccessString(ObjCIvarDecl *D) {
841   const ObjCInterfaceDecl *ClassDecl = D->getContainingInterface();
842
843   // Build name of symbol holding ivar offset.
844   std::string IvarOffsetName;
845   if (D->isBitField())
846     ObjCIvarBitfieldGroupOffset(D, IvarOffsetName);
847   else
848     WriteInternalIvarName(ClassDecl, D, IvarOffsetName);
849
850   std::string S = "(*(";
851   QualType IvarT = D->getType();
852   if (D->isBitField())
853     IvarT = GetGroupRecordTypeForObjCIvarBitfield(D);
854
855   if (!isa<TypedefType>(IvarT) && IvarT->isRecordType()) {
856     RecordDecl *RD = IvarT->castAs<RecordType>()->getDecl();
857     RD = RD->getDefinition();
858     if (RD && !RD->getDeclName().getAsIdentifierInfo()) {
859       // decltype(((Foo_IMPL*)0)->bar) *
860       auto *CDecl = cast<ObjCContainerDecl>(D->getDeclContext());
861       // ivar in class extensions requires special treatment.
862       if (ObjCCategoryDecl *CatDecl = dyn_cast<ObjCCategoryDecl>(CDecl))
863         CDecl = CatDecl->getClassInterface();
864       std::string RecName = std::string(CDecl->getName());
865       RecName += "_IMPL";
866       RecordDecl *RD =
867           RecordDecl::Create(*Context, TTK_Struct, TUDecl, SourceLocation(),
868                              SourceLocation(), &Context->Idents.get(RecName));
869       QualType PtrStructIMPL = Context->getPointerType(Context->getTagDeclType(RD));
870       unsigned UnsignedIntSize =
871       static_cast<unsigned>(Context->getTypeSize(Context->UnsignedIntTy));
872       Expr *Zero = IntegerLiteral::Create(*Context,
873                                           llvm::APInt(UnsignedIntSize, 0),
874                                           Context->UnsignedIntTy, SourceLocation());
875       Zero = NoTypeInfoCStyleCastExpr(Context, PtrStructIMPL, CK_BitCast, Zero);
876       ParenExpr *PE = new (Context) ParenExpr(SourceLocation(), SourceLocation(),
877                                               Zero);
878       FieldDecl *FD = FieldDecl::Create(*Context, nullptr, SourceLocation(),
879                                         SourceLocation(),
880                                         &Context->Idents.get(D->getNameAsString()),
881                                         IvarT, nullptr,
882                                         /*BitWidth=*/nullptr, /*Mutable=*/true,
883                                         ICIS_NoInit);
884       MemberExpr *ME = MemberExpr::CreateImplicit(
885           *Context, PE, true, FD, FD->getType(), VK_LValue, OK_Ordinary);
886       IvarT = Context->getDecltypeType(ME, ME->getType());
887     }
888   }
889   convertObjCTypeToCStyleType(IvarT);
890   QualType castT = Context->getPointerType(IvarT);
891   std::string TypeString(castT.getAsString(Context->getPrintingPolicy()));
892   S += TypeString;
893   S += ")";
894
895   // ((char *)self + IVAR_OFFSET_SYMBOL_NAME)
896   S += "((char *)self + ";
897   S += IvarOffsetName;
898   S += "))";
899   if (D->isBitField()) {
900     S += ".";
901     S += D->getNameAsString();
902   }
903   ReferencedIvars[const_cast<ObjCInterfaceDecl *>(ClassDecl)].insert(D);
904   return S;
905 }
906
907 /// mustSynthesizeSetterGetterMethod - returns true if setter or getter has not
908 /// been found in the class implementation. In this case, it must be synthesized.
909 static bool mustSynthesizeSetterGetterMethod(ObjCImplementationDecl *IMP,
910                                              ObjCPropertyDecl *PD,
911                                              bool getter) {
912   auto *OMD = IMP->getInstanceMethod(getter ? PD->getGetterName()
913                                             : PD->getSetterName());
914   return !OMD || OMD->isSynthesizedAccessorStub();
915 }
916
917 void RewriteModernObjC::RewritePropertyImplDecl(ObjCPropertyImplDecl *PID,
918                                           ObjCImplementationDecl *IMD,
919                                           ObjCCategoryImplDecl *CID) {
920   static bool objcGetPropertyDefined = false;
921   static bool objcSetPropertyDefined = false;
922   SourceLocation startGetterSetterLoc;
923
924   if (PID->getBeginLoc().isValid()) {
925     SourceLocation startLoc = PID->getBeginLoc();
926     InsertText(startLoc, "// ");
927     const char *startBuf = SM->getCharacterData(startLoc);
928     assert((*startBuf == '@') && "bogus @synthesize location");
929     const char *semiBuf = strchr(startBuf, ';');
930     assert((*semiBuf == ';') && "@synthesize: can't find ';'");
931     startGetterSetterLoc = startLoc.getLocWithOffset(semiBuf-startBuf+1);
932   } else
933     startGetterSetterLoc = IMD ? IMD->getEndLoc() : CID->getEndLoc();
934
935   if (PID->getPropertyImplementation() == ObjCPropertyImplDecl::Dynamic)
936     return; // FIXME: is this correct?
937
938   // Generate the 'getter' function.
939   ObjCPropertyDecl *PD = PID->getPropertyDecl();
940   ObjCIvarDecl *OID = PID->getPropertyIvarDecl();
941   assert(IMD && OID && "Synthesized ivars must be attached to @implementation");
942
943   unsigned Attributes = PD->getPropertyAttributes();
944   if (mustSynthesizeSetterGetterMethod(IMD, PD, true /*getter*/)) {
945     bool GenGetProperty =
946         !(Attributes & ObjCPropertyAttribute::kind_nonatomic) &&
947         (Attributes & (ObjCPropertyAttribute::kind_retain |
948                        ObjCPropertyAttribute::kind_copy));
949     std::string Getr;
950     if (GenGetProperty && !objcGetPropertyDefined) {
951       objcGetPropertyDefined = true;
952       // FIXME. Is this attribute correct in all cases?
953       Getr = "\nextern \"C\" __declspec(dllimport) "
954             "id objc_getProperty(id, SEL, long, bool);\n";
955     }
956     RewriteObjCMethodDecl(OID->getContainingInterface(),
957                           PID->getGetterMethodDecl(), Getr);
958     Getr += "{ ";
959     // Synthesize an explicit cast to gain access to the ivar.
960     // See objc-act.c:objc_synthesize_new_getter() for details.
961     if (GenGetProperty) {
962       // return objc_getProperty(self, _cmd, offsetof(ClassDecl, OID), 1)
963       Getr += "typedef ";
964       const FunctionType *FPRetType = nullptr;
965       RewriteTypeIntoString(PID->getGetterMethodDecl()->getReturnType(), Getr,
966                             FPRetType);
967       Getr += " _TYPE";
968       if (FPRetType) {
969         Getr += ")"; // close the precedence "scope" for "*".
970
971         // Now, emit the argument types (if any).
972         if (const FunctionProtoType *FT = dyn_cast<FunctionProtoType>(FPRetType)){
973           Getr += "(";
974           for (unsigned i = 0, e = FT->getNumParams(); i != e; ++i) {
975             if (i) Getr += ", ";
976             std::string ParamStr =
977                 FT->getParamType(i).getAsString(Context->getPrintingPolicy());
978             Getr += ParamStr;
979           }
980           if (FT->isVariadic()) {
981             if (FT->getNumParams())
982               Getr += ", ";
983             Getr += "...";
984           }
985           Getr += ")";
986         } else
987           Getr += "()";
988       }
989       Getr += ";\n";
990       Getr += "return (_TYPE)";
991       Getr += "objc_getProperty(self, _cmd, ";
992       RewriteIvarOffsetComputation(OID, Getr);
993       Getr += ", 1)";
994     }
995     else
996       Getr += "return " + getIvarAccessString(OID);
997     Getr += "; }";
998     InsertText(startGetterSetterLoc, Getr);
999   }
1000
1001   if (PD->isReadOnly() ||
1002       !mustSynthesizeSetterGetterMethod(IMD, PD, false /*setter*/))
1003     return;
1004
1005   // Generate the 'setter' function.
1006   std::string Setr;
1007   bool GenSetProperty = Attributes & (ObjCPropertyAttribute::kind_retain |
1008                                       ObjCPropertyAttribute::kind_copy);
1009   if (GenSetProperty && !objcSetPropertyDefined) {
1010     objcSetPropertyDefined = true;
1011     // FIXME. Is this attribute correct in all cases?
1012     Setr = "\nextern \"C\" __declspec(dllimport) "
1013     "void objc_setProperty (id, SEL, long, id, bool, bool);\n";
1014   }
1015
1016   RewriteObjCMethodDecl(OID->getContainingInterface(),
1017                         PID->getSetterMethodDecl(), Setr);
1018   Setr += "{ ";
1019   // Synthesize an explicit cast to initialize the ivar.
1020   // See objc-act.c:objc_synthesize_new_setter() for details.
1021   if (GenSetProperty) {
1022     Setr += "objc_setProperty (self, _cmd, ";
1023     RewriteIvarOffsetComputation(OID, Setr);
1024     Setr += ", (id)";
1025     Setr += PD->getName();
1026     Setr += ", ";
1027     if (Attributes & ObjCPropertyAttribute::kind_nonatomic)
1028       Setr += "0, ";
1029     else
1030       Setr += "1, ";
1031     if (Attributes & ObjCPropertyAttribute::kind_copy)
1032       Setr += "1)";
1033     else
1034       Setr += "0)";
1035   }
1036   else {
1037     Setr += getIvarAccessString(OID) + " = ";
1038     Setr += PD->getName();
1039   }
1040   Setr += "; }\n";
1041   InsertText(startGetterSetterLoc, Setr);
1042 }
1043
1044 static void RewriteOneForwardClassDecl(ObjCInterfaceDecl *ForwardDecl,
1045                                        std::string &typedefString) {
1046   typedefString += "\n#ifndef _REWRITER_typedef_";
1047   typedefString += ForwardDecl->getNameAsString();
1048   typedefString += "\n";
1049   typedefString += "#define _REWRITER_typedef_";
1050   typedefString += ForwardDecl->getNameAsString();
1051   typedefString += "\n";
1052   typedefString += "typedef struct objc_object ";
1053   typedefString += ForwardDecl->getNameAsString();
1054   // typedef struct { } _objc_exc_Classname;
1055   typedefString += ";\ntypedef struct {} _objc_exc_";
1056   typedefString += ForwardDecl->getNameAsString();
1057   typedefString += ";\n#endif\n";
1058 }
1059
1060 void RewriteModernObjC::RewriteForwardClassEpilogue(ObjCInterfaceDecl *ClassDecl,
1061                                               const std::string &typedefString) {
1062   SourceLocation startLoc = ClassDecl->getBeginLoc();
1063   const char *startBuf = SM->getCharacterData(startLoc);
1064   const char *semiPtr = strchr(startBuf, ';');
1065   // Replace the @class with typedefs corresponding to the classes.
1066   ReplaceText(startLoc, semiPtr-startBuf+1, typedefString);
1067 }
1068
1069 void RewriteModernObjC::RewriteForwardClassDecl(DeclGroupRef D) {
1070   std::string typedefString;
1071   for (DeclGroupRef::iterator I = D.begin(), E = D.end(); I != E; ++I) {
1072     if (ObjCInterfaceDecl *ForwardDecl = dyn_cast<ObjCInterfaceDecl>(*I)) {
1073       if (I == D.begin()) {
1074         // Translate to typedef's that forward reference structs with the same name
1075         // as the class. As a convenience, we include the original declaration
1076         // as a comment.
1077         typedefString += "// @class ";
1078         typedefString += ForwardDecl->getNameAsString();
1079         typedefString += ";";
1080       }
1081       RewriteOneForwardClassDecl(ForwardDecl, typedefString);
1082     }
1083     else
1084       HandleTopLevelSingleDecl(*I);
1085   }
1086   DeclGroupRef::iterator I = D.begin();
1087   RewriteForwardClassEpilogue(cast<ObjCInterfaceDecl>(*I), typedefString);
1088 }
1089
1090 void RewriteModernObjC::RewriteForwardClassDecl(
1091                                 const SmallVectorImpl<Decl *> &D) {
1092   std::string typedefString;
1093   for (unsigned i = 0; i < D.size(); i++) {
1094     ObjCInterfaceDecl *ForwardDecl = cast<ObjCInterfaceDecl>(D[i]);
1095     if (i == 0) {
1096       typedefString += "// @class ";
1097       typedefString += ForwardDecl->getNameAsString();
1098       typedefString += ";";
1099     }
1100     RewriteOneForwardClassDecl(ForwardDecl, typedefString);
1101   }
1102   RewriteForwardClassEpilogue(cast<ObjCInterfaceDecl>(D[0]), typedefString);
1103 }
1104
1105 void RewriteModernObjC::RewriteMethodDeclaration(ObjCMethodDecl *Method) {
1106   // When method is a synthesized one, such as a getter/setter there is
1107   // nothing to rewrite.
1108   if (Method->isImplicit())
1109     return;
1110   SourceLocation LocStart = Method->getBeginLoc();
1111   SourceLocation LocEnd = Method->getEndLoc();
1112
1113   if (SM->getExpansionLineNumber(LocEnd) >
1114       SM->getExpansionLineNumber(LocStart)) {
1115     InsertText(LocStart, "#if 0\n");
1116     ReplaceText(LocEnd, 1, ";\n#endif\n");
1117   } else {
1118     InsertText(LocStart, "// ");
1119   }
1120 }
1121
1122 void RewriteModernObjC::RewriteProperty(ObjCPropertyDecl *prop) {
1123   SourceLocation Loc = prop->getAtLoc();
1124
1125   ReplaceText(Loc, 0, "// ");
1126   // FIXME: handle properties that are declared across multiple lines.
1127 }
1128
1129 void RewriteModernObjC::RewriteCategoryDecl(ObjCCategoryDecl *CatDecl) {
1130   SourceLocation LocStart = CatDecl->getBeginLoc();
1131
1132   // FIXME: handle category headers that are declared across multiple lines.
1133   if (CatDecl->getIvarRBraceLoc().isValid()) {
1134     ReplaceText(LocStart, 1, "/** ");
1135     ReplaceText(CatDecl->getIvarRBraceLoc(), 1, "**/ ");
1136   }
1137   else {
1138     ReplaceText(LocStart, 0, "// ");
1139   }
1140
1141   for (auto *I : CatDecl->instance_properties())
1142     RewriteProperty(I);
1143
1144   for (auto *I : CatDecl->instance_methods())
1145     RewriteMethodDeclaration(I);
1146   for (auto *I : CatDecl->class_methods())
1147     RewriteMethodDeclaration(I);
1148
1149   // Lastly, comment out the @end.
1150   ReplaceText(CatDecl->getAtEndRange().getBegin(),
1151               strlen("@end"), "/* @end */\n");
1152 }
1153
1154 void RewriteModernObjC::RewriteProtocolDecl(ObjCProtocolDecl *PDecl) {
1155   SourceLocation LocStart = PDecl->getBeginLoc();
1156   assert(PDecl->isThisDeclarationADefinition());
1157
1158   // FIXME: handle protocol headers that are declared across multiple lines.
1159   ReplaceText(LocStart, 0, "// ");
1160
1161   for (auto *I : PDecl->instance_methods())
1162     RewriteMethodDeclaration(I);
1163   for (auto *I : PDecl->class_methods())
1164     RewriteMethodDeclaration(I);
1165   for (auto *I : PDecl->instance_properties())
1166     RewriteProperty(I);
1167
1168   // Lastly, comment out the @end.
1169   SourceLocation LocEnd = PDecl->getAtEndRange().getBegin();
1170   ReplaceText(LocEnd, strlen("@end"), "/* @end */\n");
1171
1172   // Must comment out @optional/@required
1173   const char *startBuf = SM->getCharacterData(LocStart);
1174   const char *endBuf = SM->getCharacterData(LocEnd);
1175   for (const char *p = startBuf; p < endBuf; p++) {
1176     if (*p == '@' && !strncmp(p+1, "optional", strlen("optional"))) {
1177       SourceLocation OptionalLoc = LocStart.getLocWithOffset(p-startBuf);
1178       ReplaceText(OptionalLoc, strlen("@optional"), "/* @optional */");
1179
1180     }
1181     else if (*p == '@' && !strncmp(p+1, "required", strlen("required"))) {
1182       SourceLocation OptionalLoc = LocStart.getLocWithOffset(p-startBuf);
1183       ReplaceText(OptionalLoc, strlen("@required"), "/* @required */");
1184
1185     }
1186   }
1187 }
1188
1189 void RewriteModernObjC::RewriteForwardProtocolDecl(DeclGroupRef D) {
1190   SourceLocation LocStart = (*D.begin())->getBeginLoc();
1191   if (LocStart.isInvalid())
1192     llvm_unreachable("Invalid SourceLocation");
1193   // FIXME: handle forward protocol that are declared across multiple lines.
1194   ReplaceText(LocStart, 0, "// ");
1195 }
1196
1197 void
1198 RewriteModernObjC::RewriteForwardProtocolDecl(const SmallVectorImpl<Decl *> &DG) {
1199   SourceLocation LocStart = DG[0]->getBeginLoc();
1200   if (LocStart.isInvalid())
1201     llvm_unreachable("Invalid SourceLocation");
1202   // FIXME: handle forward protocol that are declared across multiple lines.
1203   ReplaceText(LocStart, 0, "// ");
1204 }
1205
1206 void RewriteModernObjC::RewriteTypeIntoString(QualType T, std::string &ResultStr,
1207                                         const FunctionType *&FPRetType) {
1208   if (T->isObjCQualifiedIdType())
1209     ResultStr += "id";
1210   else if (T->isFunctionPointerType() ||
1211            T->isBlockPointerType()) {
1212     // needs special handling, since pointer-to-functions have special
1213     // syntax (where a decaration models use).
1214     QualType retType = T;
1215     QualType PointeeTy;
1216     if (const PointerType* PT = retType->getAs<PointerType>())
1217       PointeeTy = PT->getPointeeType();
1218     else if (const BlockPointerType *BPT = retType->getAs<BlockPointerType>())
1219       PointeeTy = BPT->getPointeeType();
1220     if ((FPRetType = PointeeTy->getAs<FunctionType>())) {
1221       ResultStr +=
1222           FPRetType->getReturnType().getAsString(Context->getPrintingPolicy());
1223       ResultStr += "(*";
1224     }
1225   } else
1226     ResultStr += T.getAsString(Context->getPrintingPolicy());
1227 }
1228
1229 void RewriteModernObjC::RewriteObjCMethodDecl(const ObjCInterfaceDecl *IDecl,
1230                                         ObjCMethodDecl *OMD,
1231                                         std::string &ResultStr) {
1232   //fprintf(stderr,"In RewriteObjCMethodDecl\n");
1233   const FunctionType *FPRetType = nullptr;
1234   ResultStr += "\nstatic ";
1235   RewriteTypeIntoString(OMD->getReturnType(), ResultStr, FPRetType);
1236   ResultStr += " ";
1237
1238   // Unique method name
1239   std::string NameStr;
1240
1241   if (OMD->isInstanceMethod())
1242     NameStr += "_I_";
1243   else
1244     NameStr += "_C_";
1245
1246   NameStr += IDecl->getNameAsString();
1247   NameStr += "_";
1248
1249   if (ObjCCategoryImplDecl *CID =
1250       dyn_cast<ObjCCategoryImplDecl>(OMD->getDeclContext())) {
1251     NameStr += CID->getNameAsString();
1252     NameStr += "_";
1253   }
1254   // Append selector names, replacing ':' with '_'
1255   {
1256     std::string selString = OMD->getSelector().getAsString();
1257     int len = selString.size();
1258     for (int i = 0; i < len; i++)
1259       if (selString[i] == ':')
1260         selString[i] = '_';
1261     NameStr += selString;
1262   }
1263   // Remember this name for metadata emission
1264   MethodInternalNames[OMD] = NameStr;
1265   ResultStr += NameStr;
1266
1267   // Rewrite arguments
1268   ResultStr += "(";
1269
1270   // invisible arguments
1271   if (OMD->isInstanceMethod()) {
1272     QualType selfTy = Context->getObjCInterfaceType(IDecl);
1273     selfTy = Context->getPointerType(selfTy);
1274     if (!LangOpts.MicrosoftExt) {
1275       if (ObjCSynthesizedStructs.count(const_cast<ObjCInterfaceDecl*>(IDecl)))
1276         ResultStr += "struct ";
1277     }
1278     // When rewriting for Microsoft, explicitly omit the structure name.
1279     ResultStr += IDecl->getNameAsString();
1280     ResultStr += " *";
1281   }
1282   else
1283     ResultStr += Context->getObjCClassType().getAsString(
1284       Context->getPrintingPolicy());
1285
1286   ResultStr += " self, ";
1287   ResultStr += Context->getObjCSelType().getAsString(Context->getPrintingPolicy());
1288   ResultStr += " _cmd";
1289
1290   // Method arguments.
1291   for (const auto *PDecl : OMD->parameters()) {
1292     ResultStr += ", ";
1293     if (PDecl->getType()->isObjCQualifiedIdType()) {
1294       ResultStr += "id ";
1295       ResultStr += PDecl->getNameAsString();
1296     } else {
1297       std::string Name = PDecl->getNameAsString();
1298       QualType QT = PDecl->getType();
1299       // Make sure we convert "t (^)(...)" to "t (*)(...)".
1300       (void)convertBlockPointerToFunctionPointer(QT);
1301       QT.getAsStringInternal(Name, Context->getPrintingPolicy());
1302       ResultStr += Name;
1303     }
1304   }
1305   if (OMD->isVariadic())
1306     ResultStr += ", ...";
1307   ResultStr += ") ";
1308
1309   if (FPRetType) {
1310     ResultStr += ")"; // close the precedence "scope" for "*".
1311
1312     // Now, emit the argument types (if any).
1313     if (const FunctionProtoType *FT = dyn_cast<FunctionProtoType>(FPRetType)) {
1314       ResultStr += "(";
1315       for (unsigned i = 0, e = FT->getNumParams(); i != e; ++i) {
1316         if (i) ResultStr += ", ";
1317         std::string ParamStr =
1318             FT->getParamType(i).getAsString(Context->getPrintingPolicy());
1319         ResultStr += ParamStr;
1320       }
1321       if (FT->isVariadic()) {
1322         if (FT->getNumParams())
1323           ResultStr += ", ";
1324         ResultStr += "...";
1325       }
1326       ResultStr += ")";
1327     } else {
1328       ResultStr += "()";
1329     }
1330   }
1331 }
1332
1333 void RewriteModernObjC::RewriteImplementationDecl(Decl *OID) {
1334   ObjCImplementationDecl *IMD = dyn_cast<ObjCImplementationDecl>(OID);
1335   ObjCCategoryImplDecl *CID = dyn_cast<ObjCCategoryImplDecl>(OID);
1336   assert((IMD || CID) && "Unknown implementation type");
1337
1338   if (IMD) {
1339     if (IMD->getIvarRBraceLoc().isValid()) {
1340       ReplaceText(IMD->getBeginLoc(), 1, "/** ");
1341       ReplaceText(IMD->getIvarRBraceLoc(), 1, "**/ ");
1342     }
1343     else {
1344       InsertText(IMD->getBeginLoc(), "// ");
1345     }
1346   }
1347   else
1348     InsertText(CID->getBeginLoc(), "// ");
1349
1350   for (auto *OMD : IMD ? IMD->instance_methods() : CID->instance_methods()) {
1351     if (!OMD->getBody())
1352       continue;
1353     std::string ResultStr;
1354     RewriteObjCMethodDecl(OMD->getClassInterface(), OMD, ResultStr);
1355     SourceLocation LocStart = OMD->getBeginLoc();
1356     SourceLocation LocEnd = OMD->getCompoundBody()->getBeginLoc();
1357
1358     const char *startBuf = SM->getCharacterData(LocStart);
1359     const char *endBuf = SM->getCharacterData(LocEnd);
1360     ReplaceText(LocStart, endBuf-startBuf, ResultStr);
1361   }
1362
1363   for (auto *OMD : IMD ? IMD->class_methods() : CID->class_methods()) {
1364     if (!OMD->getBody())
1365       continue;
1366     std::string ResultStr;
1367     RewriteObjCMethodDecl(OMD->getClassInterface(), OMD, ResultStr);
1368     SourceLocation LocStart = OMD->getBeginLoc();
1369     SourceLocation LocEnd = OMD->getCompoundBody()->getBeginLoc();
1370
1371     const char *startBuf = SM->getCharacterData(LocStart);
1372     const char *endBuf = SM->getCharacterData(LocEnd);
1373     ReplaceText(LocStart, endBuf-startBuf, ResultStr);
1374   }
1375   for (auto *I : IMD ? IMD->property_impls() : CID->property_impls())
1376     RewritePropertyImplDecl(I, IMD, CID);
1377
1378   InsertText(IMD ? IMD->getEndLoc() : CID->getEndLoc(), "// ");
1379 }
1380
1381 void RewriteModernObjC::RewriteInterfaceDecl(ObjCInterfaceDecl *ClassDecl) {
1382   // Do not synthesize more than once.
1383   if (ObjCSynthesizedStructs.count(ClassDecl))
1384     return;
1385   // Make sure super class's are written before current class is written.
1386   ObjCInterfaceDecl *SuperClass = ClassDecl->getSuperClass();
1387   while (SuperClass) {
1388     RewriteInterfaceDecl(SuperClass);
1389     SuperClass = SuperClass->getSuperClass();
1390   }
1391   std::string ResultStr;
1392   if (!ObjCWrittenInterfaces.count(ClassDecl->getCanonicalDecl())) {
1393     // we haven't seen a forward decl - generate a typedef.
1394     RewriteOneForwardClassDecl(ClassDecl, ResultStr);
1395     RewriteIvarOffsetSymbols(ClassDecl, ResultStr);
1396
1397     RewriteObjCInternalStruct(ClassDecl, ResultStr);
1398     // Mark this typedef as having been written into its c++ equivalent.
1399     ObjCWrittenInterfaces.insert(ClassDecl->getCanonicalDecl());
1400
1401     for (auto *I : ClassDecl->instance_properties())
1402       RewriteProperty(I);
1403     for (auto *I : ClassDecl->instance_methods())
1404       RewriteMethodDeclaration(I);
1405     for (auto *I : ClassDecl->class_methods())
1406       RewriteMethodDeclaration(I);
1407
1408     // Lastly, comment out the @end.
1409     ReplaceText(ClassDecl->getAtEndRange().getBegin(), strlen("@end"),
1410                 "/* @end */\n");
1411   }
1412 }
1413
1414 Stmt *RewriteModernObjC::RewritePropertyOrImplicitSetter(PseudoObjectExpr *PseudoOp) {
1415   SourceRange OldRange = PseudoOp->getSourceRange();
1416
1417   // We just magically know some things about the structure of this
1418   // expression.
1419   ObjCMessageExpr *OldMsg =
1420     cast<ObjCMessageExpr>(PseudoOp->getSemanticExpr(
1421                             PseudoOp->getNumSemanticExprs() - 1));
1422
1423   // Because the rewriter doesn't allow us to rewrite rewritten code,
1424   // we need to suppress rewriting the sub-statements.
1425   Expr *Base;
1426   SmallVector<Expr*, 2> Args;
1427   {
1428     DisableReplaceStmtScope S(*this);
1429
1430     // Rebuild the base expression if we have one.
1431     Base = nullptr;
1432     if (OldMsg->getReceiverKind() == ObjCMessageExpr::Instance) {
1433       Base = OldMsg->getInstanceReceiver();
1434       Base = cast<OpaqueValueExpr>(Base)->getSourceExpr();
1435       Base = cast<Expr>(RewriteFunctionBodyOrGlobalInitializer(Base));
1436     }
1437
1438     unsigned numArgs = OldMsg->getNumArgs();
1439     for (unsigned i = 0; i < numArgs; i++) {
1440       Expr *Arg = OldMsg->getArg(i);
1441       if (isa<OpaqueValueExpr>(Arg))
1442         Arg = cast<OpaqueValueExpr>(Arg)->getSourceExpr();
1443       Arg = cast<Expr>(RewriteFunctionBodyOrGlobalInitializer(Arg));
1444       Args.push_back(Arg);
1445     }
1446   }
1447
1448   // TODO: avoid this copy.
1449   SmallVector<SourceLocation, 1> SelLocs;
1450   OldMsg->getSelectorLocs(SelLocs);
1451
1452   ObjCMessageExpr *NewMsg = nullptr;
1453   switch (OldMsg->getReceiverKind()) {
1454   case ObjCMessageExpr::Class:
1455     NewMsg = ObjCMessageExpr::Create(*Context, OldMsg->getType(),
1456                                      OldMsg->getValueKind(),
1457                                      OldMsg->getLeftLoc(),
1458                                      OldMsg->getClassReceiverTypeInfo(),
1459                                      OldMsg->getSelector(),
1460                                      SelLocs,
1461                                      OldMsg->getMethodDecl(),
1462                                      Args,
1463                                      OldMsg->getRightLoc(),
1464                                      OldMsg->isImplicit());
1465     break;
1466
1467   case ObjCMessageExpr::Instance:
1468     NewMsg = ObjCMessageExpr::Create(*Context, OldMsg->getType(),
1469                                      OldMsg->getValueKind(),
1470                                      OldMsg->getLeftLoc(),
1471                                      Base,
1472                                      OldMsg->getSelector(),
1473                                      SelLocs,
1474                                      OldMsg->getMethodDecl(),
1475                                      Args,
1476                                      OldMsg->getRightLoc(),
1477                                      OldMsg->isImplicit());
1478     break;
1479
1480   case ObjCMessageExpr::SuperClass:
1481   case ObjCMessageExpr::SuperInstance:
1482     NewMsg = ObjCMessageExpr::Create(*Context, OldMsg->getType(),
1483                                      OldMsg->getValueKind(),
1484                                      OldMsg->getLeftLoc(),
1485                                      OldMsg->getSuperLoc(),
1486                  OldMsg->getReceiverKind() == ObjCMessageExpr::SuperInstance,
1487                                      OldMsg->getSuperType(),
1488                                      OldMsg->getSelector(),
1489                                      SelLocs,
1490                                      OldMsg->getMethodDecl(),
1491                                      Args,
1492                                      OldMsg->getRightLoc(),
1493                                      OldMsg->isImplicit());
1494     break;
1495   }
1496
1497   Stmt *Replacement = SynthMessageExpr(NewMsg);
1498   ReplaceStmtWithRange(PseudoOp, Replacement, OldRange);
1499   return Replacement;
1500 }
1501
1502 Stmt *RewriteModernObjC::RewritePropertyOrImplicitGetter(PseudoObjectExpr *PseudoOp) {
1503   SourceRange OldRange = PseudoOp->getSourceRange();
1504
1505   // We just magically know some things about the structure of this
1506   // expression.
1507   ObjCMessageExpr *OldMsg =
1508     cast<ObjCMessageExpr>(PseudoOp->getResultExpr()->IgnoreImplicit());
1509
1510   // Because the rewriter doesn't allow us to rewrite rewritten code,
1511   // we need to suppress rewriting the sub-statements.
1512   Expr *Base = nullptr;
1513   SmallVector<Expr*, 1> Args;
1514   {
1515     DisableReplaceStmtScope S(*this);
1516     // Rebuild the base expression if we have one.
1517     if (OldMsg->getReceiverKind() == ObjCMessageExpr::Instance) {
1518       Base = OldMsg->getInstanceReceiver();
1519       Base = cast<OpaqueValueExpr>(Base)->getSourceExpr();
1520       Base = cast<Expr>(RewriteFunctionBodyOrGlobalInitializer(Base));
1521     }
1522     unsigned numArgs = OldMsg->getNumArgs();
1523     for (unsigned i = 0; i < numArgs; i++) {
1524       Expr *Arg = OldMsg->getArg(i);
1525       if (isa<OpaqueValueExpr>(Arg))
1526         Arg = cast<OpaqueValueExpr>(Arg)->getSourceExpr();
1527       Arg = cast<Expr>(RewriteFunctionBodyOrGlobalInitializer(Arg));
1528       Args.push_back(Arg);
1529     }
1530   }
1531
1532   // Intentionally empty.
1533   SmallVector<SourceLocation, 1> SelLocs;
1534
1535   ObjCMessageExpr *NewMsg = nullptr;
1536   switch (OldMsg->getReceiverKind()) {
1537   case ObjCMessageExpr::Class:
1538     NewMsg = ObjCMessageExpr::Create(*Context, OldMsg->getType(),
1539                                      OldMsg->getValueKind(),
1540                                      OldMsg->getLeftLoc(),
1541                                      OldMsg->getClassReceiverTypeInfo(),
1542                                      OldMsg->getSelector(),
1543                                      SelLocs,
1544                                      OldMsg->getMethodDecl(),
1545                                      Args,
1546                                      OldMsg->getRightLoc(),
1547                                      OldMsg->isImplicit());
1548     break;
1549
1550   case ObjCMessageExpr::Instance:
1551     NewMsg = ObjCMessageExpr::Create(*Context, OldMsg->getType(),
1552                                      OldMsg->getValueKind(),
1553                                      OldMsg->getLeftLoc(),
1554                                      Base,
1555                                      OldMsg->getSelector(),
1556                                      SelLocs,
1557                                      OldMsg->getMethodDecl(),
1558                                      Args,
1559                                      OldMsg->getRightLoc(),
1560                                      OldMsg->isImplicit());
1561     break;
1562
1563   case ObjCMessageExpr::SuperClass:
1564   case ObjCMessageExpr::SuperInstance:
1565     NewMsg = ObjCMessageExpr::Create(*Context, OldMsg->getType(),
1566                                      OldMsg->getValueKind(),
1567                                      OldMsg->getLeftLoc(),
1568                                      OldMsg->getSuperLoc(),
1569                  OldMsg->getReceiverKind() == ObjCMessageExpr::SuperInstance,
1570                                      OldMsg->getSuperType(),
1571                                      OldMsg->getSelector(),
1572                                      SelLocs,
1573                                      OldMsg->getMethodDecl(),
1574                                      Args,
1575                                      OldMsg->getRightLoc(),
1576                                      OldMsg->isImplicit());
1577     break;
1578   }
1579
1580   Stmt *Replacement = SynthMessageExpr(NewMsg);
1581   ReplaceStmtWithRange(PseudoOp, Replacement, OldRange);
1582   return Replacement;
1583 }
1584
1585 /// SynthCountByEnumWithState - To print:
1586 /// ((NSUInteger (*)
1587 ///  (id, SEL, struct __objcFastEnumerationState *, id *, NSUInteger))
1588 ///  (void *)objc_msgSend)((id)l_collection,
1589 ///                        sel_registerName(
1590 ///                          "countByEnumeratingWithState:objects:count:"),
1591 ///                        &enumState,
1592 ///                        (id *)__rw_items, (NSUInteger)16)
1593 ///
1594 void RewriteModernObjC::SynthCountByEnumWithState(std::string &buf) {
1595   buf += "((_WIN_NSUInteger (*) (id, SEL, struct __objcFastEnumerationState *, "
1596   "id *, _WIN_NSUInteger))(void *)objc_msgSend)";
1597   buf += "\n\t\t";
1598   buf += "((id)l_collection,\n\t\t";
1599   buf += "sel_registerName(\"countByEnumeratingWithState:objects:count:\"),";
1600   buf += "\n\t\t";
1601   buf += "&enumState, "
1602          "(id *)__rw_items, (_WIN_NSUInteger)16)";
1603 }
1604
1605 /// RewriteBreakStmt - Rewrite for a break-stmt inside an ObjC2's foreach
1606 /// statement to exit to its outer synthesized loop.
1607 ///
1608 Stmt *RewriteModernObjC::RewriteBreakStmt(BreakStmt *S) {
1609   if (Stmts.empty() || !isa<ObjCForCollectionStmt>(Stmts.back()))
1610     return S;
1611   // replace break with goto __break_label
1612   std::string buf;
1613
1614   SourceLocation startLoc = S->getBeginLoc();
1615   buf = "goto __break_label_";
1616   buf += utostr(ObjCBcLabelNo.back());
1617   ReplaceText(startLoc, strlen("break"), buf);
1618
1619   return nullptr;
1620 }
1621
1622 void RewriteModernObjC::ConvertSourceLocationToLineDirective(
1623                                           SourceLocation Loc,
1624                                           std::string &LineString) {
1625   if (Loc.isFileID() && GenerateLineInfo) {
1626     LineString += "\n#line ";
1627     PresumedLoc PLoc = SM->getPresumedLoc(Loc);
1628     LineString += utostr(PLoc.getLine());
1629     LineString += " \"";
1630     LineString += Lexer::Stringify(PLoc.getFilename());
1631     LineString += "\"\n";
1632   }
1633 }
1634
1635 /// RewriteContinueStmt - Rewrite for a continue-stmt inside an ObjC2's foreach
1636 /// statement to continue with its inner synthesized loop.
1637 ///
1638 Stmt *RewriteModernObjC::RewriteContinueStmt(ContinueStmt *S) {
1639   if (Stmts.empty() || !isa<ObjCForCollectionStmt>(Stmts.back()))
1640     return S;
1641   // replace continue with goto __continue_label
1642   std::string buf;
1643
1644   SourceLocation startLoc = S->getBeginLoc();
1645   buf = "goto __continue_label_";
1646   buf += utostr(ObjCBcLabelNo.back());
1647   ReplaceText(startLoc, strlen("continue"), buf);
1648
1649   return nullptr;
1650 }
1651
1652 /// RewriteObjCForCollectionStmt - Rewriter for ObjC2's foreach statement.
1653 ///  It rewrites:
1654 /// for ( type elem in collection) { stmts; }
1655
1656 /// Into:
1657 /// {
1658 ///   type elem;
1659 ///   struct __objcFastEnumerationState enumState = { 0 };
1660 ///   id __rw_items[16];
1661 ///   id l_collection = (id)collection;
1662 ///   NSUInteger limit = [l_collection countByEnumeratingWithState:&enumState
1663 ///                                       objects:__rw_items count:16];
1664 /// if (limit) {
1665 ///   unsigned long startMutations = *enumState.mutationsPtr;
1666 ///   do {
1667 ///        unsigned long counter = 0;
1668 ///        do {
1669 ///             if (startMutations != *enumState.mutationsPtr)
1670 ///               objc_enumerationMutation(l_collection);
1671 ///             elem = (type)enumState.itemsPtr[counter++];
1672 ///             stmts;
1673 ///             __continue_label: ;
1674 ///        } while (counter < limit);
1675 ///   } while ((limit = [l_collection countByEnumeratingWithState:&enumState
1676 ///                                  objects:__rw_items count:16]));
1677 ///   elem = nil;
1678 ///   __break_label: ;
1679 ///  }
1680 ///  else
1681 ///       elem = nil;
1682 ///  }
1683 ///
1684 Stmt *RewriteModernObjC::RewriteObjCForCollectionStmt(ObjCForCollectionStmt *S,
1685                                                 SourceLocation OrigEnd) {
1686   assert(!Stmts.empty() && "ObjCForCollectionStmt - Statement stack empty");
1687   assert(isa<ObjCForCollectionStmt>(Stmts.back()) &&
1688          "ObjCForCollectionStmt Statement stack mismatch");
1689   assert(!ObjCBcLabelNo.empty() &&
1690          "ObjCForCollectionStmt - Label No stack empty");
1691
1692   SourceLocation startLoc = S->getBeginLoc();
1693   const char *startBuf = SM->getCharacterData(startLoc);
1694   StringRef elementName;
1695   std::string elementTypeAsString;
1696   std::string buf;
1697   // line directive first.
1698   SourceLocation ForEachLoc = S->getForLoc();
1699   ConvertSourceLocationToLineDirective(ForEachLoc, buf);
1700   buf += "{\n\t";
1701   if (DeclStmt *DS = dyn_cast<DeclStmt>(S->getElement())) {
1702     // type elem;
1703     NamedDecl* D = cast<NamedDecl>(DS->getSingleDecl());
1704     QualType ElementType = cast<ValueDecl>(D)->getType();
1705     if (ElementType->isObjCQualifiedIdType() ||
1706         ElementType->isObjCQualifiedInterfaceType())
1707       // Simply use 'id' for all qualified types.
1708       elementTypeAsString = "id";
1709     else
1710       elementTypeAsString = ElementType.getAsString(Context->getPrintingPolicy());
1711     buf += elementTypeAsString;
1712     buf += " ";
1713     elementName = D->getName();
1714     buf += elementName;
1715     buf += ";\n\t";
1716   }
1717   else {
1718     DeclRefExpr *DR = cast<DeclRefExpr>(S->getElement());
1719     elementName = DR->getDecl()->getName();
1720     ValueDecl *VD = DR->getDecl();
1721     if (VD->getType()->isObjCQualifiedIdType() ||
1722         VD->getType()->isObjCQualifiedInterfaceType())
1723       // Simply use 'id' for all qualified types.
1724       elementTypeAsString = "id";
1725     else
1726       elementTypeAsString = VD->getType().getAsString(Context->getPrintingPolicy());
1727   }
1728
1729   // struct __objcFastEnumerationState enumState = { 0 };
1730   buf += "struct __objcFastEnumerationState enumState = { 0 };\n\t";
1731   // id __rw_items[16];
1732   buf += "id __rw_items[16];\n\t";
1733   // id l_collection = (id)
1734   buf += "id l_collection = (id)";
1735   // Find start location of 'collection' the hard way!
1736   const char *startCollectionBuf = startBuf;
1737   startCollectionBuf += 3;  // skip 'for'
1738   startCollectionBuf = strchr(startCollectionBuf, '(');
1739   startCollectionBuf++; // skip '('
1740   // find 'in' and skip it.
1741   while (*startCollectionBuf != ' ' ||
1742          *(startCollectionBuf+1) != 'i' || *(startCollectionBuf+2) != 'n' ||
1743          (*(startCollectionBuf+3) != ' ' &&
1744           *(startCollectionBuf+3) != '[' && *(startCollectionBuf+3) != '('))
1745     startCollectionBuf++;
1746   startCollectionBuf += 3;
1747
1748   // Replace: "for (type element in" with string constructed thus far.
1749   ReplaceText(startLoc, startCollectionBuf - startBuf, buf);
1750   // Replace ')' in for '(' type elem in collection ')' with ';'
1751   SourceLocation rightParenLoc = S->getRParenLoc();
1752   const char *rparenBuf = SM->getCharacterData(rightParenLoc);
1753   SourceLocation lparenLoc = startLoc.getLocWithOffset(rparenBuf-startBuf);
1754   buf = ";\n\t";
1755
1756   // unsigned long limit = [l_collection countByEnumeratingWithState:&enumState
1757   //                                   objects:__rw_items count:16];
1758   // which is synthesized into:
1759   // NSUInteger limit =
1760   // ((NSUInteger (*)
1761   //  (id, SEL, struct __objcFastEnumerationState *, id *, NSUInteger))
1762   //  (void *)objc_msgSend)((id)l_collection,
1763   //                        sel_registerName(
1764   //                          "countByEnumeratingWithState:objects:count:"),
1765   //                        (struct __objcFastEnumerationState *)&state,
1766   //                        (id *)__rw_items, (NSUInteger)16);
1767   buf += "_WIN_NSUInteger limit =\n\t\t";
1768   SynthCountByEnumWithState(buf);
1769   buf += ";\n\t";
1770   /// if (limit) {
1771   ///   unsigned long startMutations = *enumState.mutationsPtr;
1772   ///   do {
1773   ///        unsigned long counter = 0;
1774   ///        do {
1775   ///             if (startMutations != *enumState.mutationsPtr)
1776   ///               objc_enumerationMutation(l_collection);
1777   ///             elem = (type)enumState.itemsPtr[counter++];
1778   buf += "if (limit) {\n\t";
1779   buf += "unsigned long startMutations = *enumState.mutationsPtr;\n\t";
1780   buf += "do {\n\t\t";
1781   buf += "unsigned long counter = 0;\n\t\t";
1782   buf += "do {\n\t\t\t";
1783   buf += "if (startMutations != *enumState.mutationsPtr)\n\t\t\t\t";
1784   buf += "objc_enumerationMutation(l_collection);\n\t\t\t";
1785   buf += elementName;
1786   buf += " = (";
1787   buf += elementTypeAsString;
1788   buf += ")enumState.itemsPtr[counter++];";
1789   // Replace ')' in for '(' type elem in collection ')' with all of these.
1790   ReplaceText(lparenLoc, 1, buf);
1791
1792   ///            __continue_label: ;
1793   ///        } while (counter < limit);
1794   ///   } while ((limit = [l_collection countByEnumeratingWithState:&enumState
1795   ///                                  objects:__rw_items count:16]));
1796   ///   elem = nil;
1797   ///   __break_label: ;
1798   ///  }
1799   ///  else
1800   ///       elem = nil;
1801   ///  }
1802   ///
1803   buf = ";\n\t";
1804   buf += "__continue_label_";
1805   buf += utostr(ObjCBcLabelNo.back());
1806   buf += ": ;";
1807   buf += "\n\t\t";
1808   buf += "} while (counter < limit);\n\t";
1809   buf += "} while ((limit = ";
1810   SynthCountByEnumWithState(buf);
1811   buf += "));\n\t";
1812   buf += elementName;
1813   buf += " = ((";
1814   buf += elementTypeAsString;
1815   buf += ")0);\n\t";
1816   buf += "__break_label_";
1817   buf += utostr(ObjCBcLabelNo.back());
1818   buf += ": ;\n\t";
1819   buf += "}\n\t";
1820   buf += "else\n\t\t";
1821   buf += elementName;
1822   buf += " = ((";
1823   buf += elementTypeAsString;
1824   buf += ")0);\n\t";
1825   buf += "}\n";
1826
1827   // Insert all these *after* the statement body.
1828   // FIXME: If this should support Obj-C++, support CXXTryStmt
1829   if (isa<CompoundStmt>(S->getBody())) {
1830     SourceLocation endBodyLoc = OrigEnd.getLocWithOffset(1);
1831     InsertText(endBodyLoc, buf);
1832   } else {
1833     /* Need to treat single statements specially. For example:
1834      *
1835      *     for (A *a in b) if (stuff()) break;
1836      *     for (A *a in b) xxxyy;
1837      *
1838      * The following code simply scans ahead to the semi to find the actual end.
1839      */
1840     const char *stmtBuf = SM->getCharacterData(OrigEnd);
1841     const char *semiBuf = strchr(stmtBuf, ';');
1842     assert(semiBuf && "Can't find ';'");
1843     SourceLocation endBodyLoc = OrigEnd.getLocWithOffset(semiBuf-stmtBuf+1);
1844     InsertText(endBodyLoc, buf);
1845   }
1846   Stmts.pop_back();
1847   ObjCBcLabelNo.pop_back();
1848   return nullptr;
1849 }
1850
1851 static void Write_RethrowObject(std::string &buf) {
1852   buf += "{ struct _FIN { _FIN(id reth) : rethrow(reth) {}\n";
1853   buf += "\t~_FIN() { if (rethrow) objc_exception_throw(rethrow); }\n";
1854   buf += "\tid rethrow;\n";
1855   buf += "\t} _fin_force_rethow(_rethrow);";
1856 }
1857
1858 /// RewriteObjCSynchronizedStmt -
1859 /// This routine rewrites @synchronized(expr) stmt;
1860 /// into:
1861 /// objc_sync_enter(expr);
1862 /// @try stmt @finally { objc_sync_exit(expr); }
1863 ///
1864 Stmt *RewriteModernObjC::RewriteObjCSynchronizedStmt(ObjCAtSynchronizedStmt *S) {
1865   // Get the start location and compute the semi location.
1866   SourceLocation startLoc = S->getBeginLoc();
1867   const char *startBuf = SM->getCharacterData(startLoc);
1868
1869   assert((*startBuf == '@') && "bogus @synchronized location");
1870
1871   std::string buf;
1872   SourceLocation SynchLoc = S->getAtSynchronizedLoc();
1873   ConvertSourceLocationToLineDirective(SynchLoc, buf);
1874   buf += "{ id _rethrow = 0; id _sync_obj = (id)";
1875
1876   const char *lparenBuf = startBuf;
1877   while (*lparenBuf != '(') lparenBuf++;
1878   ReplaceText(startLoc, lparenBuf-startBuf+1, buf);
1879
1880   buf = "; objc_sync_enter(_sync_obj);\n";
1881   buf += "try {\n\tstruct _SYNC_EXIT { _SYNC_EXIT(id arg) : sync_exit(arg) {}";
1882   buf += "\n\t~_SYNC_EXIT() {objc_sync_exit(sync_exit);}";
1883   buf += "\n\tid sync_exit;";
1884   buf += "\n\t} _sync_exit(_sync_obj);\n";
1885
1886   // We can't use S->getSynchExpr()->getEndLoc() to find the end location, since
1887   // the sync expression is typically a message expression that's already
1888   // been rewritten! (which implies the SourceLocation's are invalid).
1889   SourceLocation RParenExprLoc = S->getSynchBody()->getBeginLoc();
1890   const char *RParenExprLocBuf = SM->getCharacterData(RParenExprLoc);
1891   while (*RParenExprLocBuf != ')') RParenExprLocBuf--;
1892   RParenExprLoc = startLoc.getLocWithOffset(RParenExprLocBuf-startBuf);
1893
1894   SourceLocation LBranceLoc = S->getSynchBody()->getBeginLoc();
1895   const char *LBraceLocBuf = SM->getCharacterData(LBranceLoc);
1896   assert (*LBraceLocBuf == '{');
1897   ReplaceText(RParenExprLoc, (LBraceLocBuf - SM->getCharacterData(RParenExprLoc) + 1), buf);
1898
1899   SourceLocation startRBraceLoc = S->getSynchBody()->getEndLoc();
1900   assert((*SM->getCharacterData(startRBraceLoc) == '}') &&
1901          "bogus @synchronized block");
1902
1903   buf = "} catch (id e) {_rethrow = e;}\n";
1904   Write_RethrowObject(buf);
1905   buf += "}\n";
1906   buf += "}\n";
1907
1908   ReplaceText(startRBraceLoc, 1, buf);
1909
1910   return nullptr;
1911 }
1912
1913 void RewriteModernObjC::WarnAboutReturnGotoStmts(Stmt *S)
1914 {
1915   // Perform a bottom up traversal of all children.
1916   for (Stmt *SubStmt : S->children())
1917     if (SubStmt)
1918       WarnAboutReturnGotoStmts(SubStmt);
1919
1920   if (isa<ReturnStmt>(S) || isa<GotoStmt>(S)) {
1921     Diags.Report(Context->getFullLoc(S->getBeginLoc()),
1922                  TryFinallyContainsReturnDiag);
1923   }
1924 }
1925
1926 Stmt *RewriteModernObjC::RewriteObjCAutoreleasePoolStmt(ObjCAutoreleasePoolStmt  *S) {
1927   SourceLocation startLoc = S->getAtLoc();
1928   ReplaceText(startLoc, strlen("@autoreleasepool"), "/* @autoreleasepool */");
1929   ReplaceText(S->getSubStmt()->getBeginLoc(), 1,
1930               "{ __AtAutoreleasePool __autoreleasepool; ");
1931
1932   return nullptr;
1933 }
1934
1935 Stmt *RewriteModernObjC::RewriteObjCTryStmt(ObjCAtTryStmt *S) {
1936   ObjCAtFinallyStmt *finalStmt = S->getFinallyStmt();
1937   bool noCatch = S->getNumCatchStmts() == 0;
1938   std::string buf;
1939   SourceLocation TryLocation = S->getAtTryLoc();
1940   ConvertSourceLocationToLineDirective(TryLocation, buf);
1941
1942   if (finalStmt) {
1943     if (noCatch)
1944       buf += "{ id volatile _rethrow = 0;\n";
1945     else {
1946       buf += "{ id volatile _rethrow = 0;\ntry {\n";
1947     }
1948   }
1949   // Get the start location and compute the semi location.
1950   SourceLocation startLoc = S->getBeginLoc();
1951   const char *startBuf = SM->getCharacterData(startLoc);
1952
1953   assert((*startBuf == '@') && "bogus @try location");
1954   if (finalStmt)
1955     ReplaceText(startLoc, 1, buf);
1956   else
1957     // @try -> try
1958     ReplaceText(startLoc, 1, "");
1959
1960   for (unsigned I = 0, N = S->getNumCatchStmts(); I != N; ++I) {
1961     ObjCAtCatchStmt *Catch = S->getCatchStmt(I);
1962     VarDecl *catchDecl = Catch->getCatchParamDecl();
1963
1964     startLoc = Catch->getBeginLoc();
1965     bool AtRemoved = false;
1966     if (catchDecl) {
1967       QualType t = catchDecl->getType();
1968       if (const ObjCObjectPointerType *Ptr = t->getAs<ObjCObjectPointerType>()) {
1969         // Should be a pointer to a class.
1970         ObjCInterfaceDecl *IDecl = Ptr->getObjectType()->getInterface();
1971         if (IDecl) {
1972           std::string Result;
1973           ConvertSourceLocationToLineDirective(Catch->getBeginLoc(), Result);
1974
1975           startBuf = SM->getCharacterData(startLoc);
1976           assert((*startBuf == '@') && "bogus @catch location");
1977           SourceLocation rParenLoc = Catch->getRParenLoc();
1978           const char *rParenBuf = SM->getCharacterData(rParenLoc);
1979
1980           // _objc_exc_Foo *_e as argument to catch.
1981           Result += "catch (_objc_exc_"; Result += IDecl->getNameAsString();
1982           Result += " *_"; Result += catchDecl->getNameAsString();
1983           Result += ")";
1984           ReplaceText(startLoc, rParenBuf-startBuf+1, Result);
1985           // Foo *e = (Foo *)_e;
1986           Result.clear();
1987           Result = "{ ";
1988           Result += IDecl->getNameAsString();
1989           Result += " *"; Result += catchDecl->getNameAsString();
1990           Result += " = ("; Result += IDecl->getNameAsString(); Result += "*)";
1991           Result += "_"; Result += catchDecl->getNameAsString();
1992
1993           Result += "; ";
1994           SourceLocation lBraceLoc = Catch->getCatchBody()->getBeginLoc();
1995           ReplaceText(lBraceLoc, 1, Result);
1996           AtRemoved = true;
1997         }
1998       }
1999     }
2000     if (!AtRemoved)
2001       // @catch -> catch
2002       ReplaceText(startLoc, 1, "");
2003
2004   }
2005   if (finalStmt) {
2006     buf.clear();
2007     SourceLocation FinallyLoc = finalStmt->getBeginLoc();
2008
2009     if (noCatch) {
2010       ConvertSourceLocationToLineDirective(FinallyLoc, buf);
2011       buf += "catch (id e) {_rethrow = e;}\n";
2012     }
2013     else {
2014       buf += "}\n";
2015       ConvertSourceLocationToLineDirective(FinallyLoc, buf);
2016       buf += "catch (id e) {_rethrow = e;}\n";
2017     }
2018
2019     SourceLocation startFinalLoc = finalStmt->getBeginLoc();
2020     ReplaceText(startFinalLoc, 8, buf);
2021     Stmt *body = finalStmt->getFinallyBody();
2022     SourceLocation startFinalBodyLoc = body->getBeginLoc();
2023     buf.clear();
2024     Write_RethrowObject(buf);
2025     ReplaceText(startFinalBodyLoc, 1, buf);
2026
2027     SourceLocation endFinalBodyLoc = body->getEndLoc();
2028     ReplaceText(endFinalBodyLoc, 1, "}\n}");
2029     // Now check for any return/continue/go statements within the @try.
2030     WarnAboutReturnGotoStmts(S->getTryBody());
2031   }
2032
2033   return nullptr;
2034 }
2035
2036 // This can't be done with ReplaceStmt(S, ThrowExpr), since
2037 // the throw expression is typically a message expression that's already
2038 // been rewritten! (which implies the SourceLocation's are invalid).
2039 Stmt *RewriteModernObjC::RewriteObjCThrowStmt(ObjCAtThrowStmt *S) {
2040   // Get the start location and compute the semi location.
2041   SourceLocation startLoc = S->getBeginLoc();
2042   const char *startBuf = SM->getCharacterData(startLoc);
2043
2044   assert((*startBuf == '@') && "bogus @throw location");
2045
2046   std::string buf;
2047   /* void objc_exception_throw(id) __attribute__((noreturn)); */
2048   if (S->getThrowExpr())
2049     buf = "objc_exception_throw(";
2050   else
2051     buf = "throw";
2052
2053   // handle "@  throw" correctly.
2054   const char *wBuf = strchr(startBuf, 'w');
2055   assert((*wBuf == 'w') && "@throw: can't find 'w'");
2056   ReplaceText(startLoc, wBuf-startBuf+1, buf);
2057
2058   SourceLocation endLoc = S->getEndLoc();
2059   const char *endBuf = SM->getCharacterData(endLoc);
2060   const char *semiBuf = strchr(endBuf, ';');
2061   assert((*semiBuf == ';') && "@throw: can't find ';'");
2062   SourceLocation semiLoc = startLoc.getLocWithOffset(semiBuf-startBuf);
2063   if (S->getThrowExpr())
2064     ReplaceText(semiLoc, 1, ");");
2065   return nullptr;
2066 }
2067
2068 Stmt *RewriteModernObjC::RewriteAtEncode(ObjCEncodeExpr *Exp) {
2069   // Create a new string expression.
2070   std::string StrEncoding;
2071   Context->getObjCEncodingForType(Exp->getEncodedType(), StrEncoding);
2072   Expr *Replacement = getStringLiteral(StrEncoding);
2073   ReplaceStmt(Exp, Replacement);
2074
2075   // Replace this subexpr in the parent.
2076   // delete Exp; leak for now, see RewritePropertyOrImplicitSetter() usage for more info.
2077   return Replacement;
2078 }
2079
2080 Stmt *RewriteModernObjC::RewriteAtSelector(ObjCSelectorExpr *Exp) {
2081   if (!SelGetUidFunctionDecl)
2082     SynthSelGetUidFunctionDecl();
2083   assert(SelGetUidFunctionDecl && "Can't find sel_registerName() decl");
2084   // Create a call to sel_registerName("selName").
2085   SmallVector<Expr*, 8> SelExprs;
2086   SelExprs.push_back(getStringLiteral(Exp->getSelector().getAsString()));
2087   CallExpr *SelExp = SynthesizeCallToFunctionDecl(SelGetUidFunctionDecl,
2088                                                   SelExprs);
2089   ReplaceStmt(Exp, SelExp);
2090   // delete Exp; leak for now, see RewritePropertyOrImplicitSetter() usage for more info.
2091   return SelExp;
2092 }
2093
2094 CallExpr *
2095 RewriteModernObjC::SynthesizeCallToFunctionDecl(FunctionDecl *FD,
2096                                                 ArrayRef<Expr *> Args,
2097                                                 SourceLocation StartLoc,
2098                                                 SourceLocation EndLoc) {
2099   // Get the type, we will need to reference it in a couple spots.
2100   QualType msgSendType = FD->getType();
2101
2102   // Create a reference to the objc_msgSend() declaration.
2103   DeclRefExpr *DRE = new (Context) DeclRefExpr(*Context, FD, false, msgSendType,
2104                                                VK_LValue, SourceLocation());
2105
2106   // Now, we cast the reference to a pointer to the objc_msgSend type.
2107   QualType pToFunc = Context->getPointerType(msgSendType);
2108   ImplicitCastExpr *ICE =
2109       ImplicitCastExpr::Create(*Context, pToFunc, CK_FunctionToPointerDecay,
2110                                DRE, nullptr, VK_RValue, FPOptionsOverride());
2111
2112   const auto *FT = msgSendType->castAs<FunctionType>();
2113   CallExpr *Exp =
2114       CallExpr::Create(*Context, ICE, Args, FT->getCallResultType(*Context),
2115                        VK_RValue, EndLoc, FPOptionsOverride());
2116   return Exp;
2117 }
2118
2119 static bool scanForProtocolRefs(const char *startBuf, const char *endBuf,
2120                                 const char *&startRef, const char *&endRef) {
2121   while (startBuf < endBuf) {
2122     if (*startBuf == '<')
2123       startRef = startBuf; // mark the start.
2124     if (*startBuf == '>') {
2125       if (startRef && *startRef == '<') {
2126         endRef = startBuf; // mark the end.
2127         return true;
2128       }
2129       return false;
2130     }
2131     startBuf++;
2132   }
2133   return false;
2134 }
2135
2136 static void scanToNextArgument(const char *&argRef) {
2137   int angle = 0;
2138   while (*argRef != ')' && (*argRef != ',' || angle > 0)) {
2139     if (*argRef == '<')
2140       angle++;
2141     else if (*argRef == '>')
2142       angle--;
2143     argRef++;
2144   }
2145   assert(angle == 0 && "scanToNextArgument - bad protocol type syntax");
2146 }
2147
2148 bool RewriteModernObjC::needToScanForQualifiers(QualType T) {
2149   if (T->isObjCQualifiedIdType())
2150     return true;
2151   if (const PointerType *PT = T->getAs<PointerType>()) {
2152     if (PT->getPointeeType()->isObjCQualifiedIdType())
2153       return true;
2154   }
2155   if (T->isObjCObjectPointerType()) {
2156     T = T->getPointeeType();
2157     return T->isObjCQualifiedInterfaceType();
2158   }
2159   if (T->isArrayType()) {
2160     QualType ElemTy = Context->getBaseElementType(T);
2161     return needToScanForQualifiers(ElemTy);
2162   }
2163   return false;
2164 }
2165
2166 void RewriteModernObjC::RewriteObjCQualifiedInterfaceTypes(Expr *E) {
2167   QualType Type = E->getType();
2168   if (needToScanForQualifiers(Type)) {
2169     SourceLocation Loc, EndLoc;
2170
2171     if (const CStyleCastExpr *ECE = dyn_cast<CStyleCastExpr>(E)) {
2172       Loc = ECE->getLParenLoc();
2173       EndLoc = ECE->getRParenLoc();
2174     } else {
2175       Loc = E->getBeginLoc();
2176       EndLoc = E->getEndLoc();
2177     }
2178     // This will defend against trying to rewrite synthesized expressions.
2179     if (Loc.isInvalid() || EndLoc.isInvalid())
2180       return;
2181
2182     const char *startBuf = SM->getCharacterData(Loc);
2183     const char *endBuf = SM->getCharacterData(EndLoc);
2184     const char *startRef = nullptr, *endRef = nullptr;
2185     if (scanForProtocolRefs(startBuf, endBuf, startRef, endRef)) {
2186       // Get the locations of the startRef, endRef.
2187       SourceLocation LessLoc = Loc.getLocWithOffset(startRef-startBuf);
2188       SourceLocation GreaterLoc = Loc.getLocWithOffset(endRef-startBuf+1);
2189       // Comment out the protocol references.
2190       InsertText(LessLoc, "/*");
2191       InsertText(GreaterLoc, "*/");
2192     }
2193   }
2194 }
2195
2196 void RewriteModernObjC::RewriteObjCQualifiedInterfaceTypes(Decl *Dcl) {
2197   SourceLocation Loc;
2198   QualType Type;
2199   const FunctionProtoType *proto = nullptr;
2200   if (VarDecl *VD = dyn_cast<VarDecl>(Dcl)) {
2201     Loc = VD->getLocation();
2202     Type = VD->getType();
2203   }
2204   else if (FunctionDecl *FD = dyn_cast<FunctionDecl>(Dcl)) {
2205     Loc = FD->getLocation();
2206     // Check for ObjC 'id' and class types that have been adorned with protocol
2207     // information (id<p>, C<p>*). The protocol references need to be rewritten!
2208     const FunctionType *funcType = FD->getType()->getAs<FunctionType>();
2209     assert(funcType && "missing function type");
2210     proto = dyn_cast<FunctionProtoType>(funcType);
2211     if (!proto)
2212       return;
2213     Type = proto->getReturnType();
2214   }
2215   else if (FieldDecl *FD = dyn_cast<FieldDecl>(Dcl)) {
2216     Loc = FD->getLocation();
2217     Type = FD->getType();
2218   }
2219   else if (TypedefNameDecl *TD = dyn_cast<TypedefNameDecl>(Dcl)) {
2220     Loc = TD->getLocation();
2221     Type = TD->getUnderlyingType();
2222   }
2223   else
2224     return;
2225
2226   if (needToScanForQualifiers(Type)) {
2227     // Since types are unique, we need to scan the buffer.
2228
2229     const char *endBuf = SM->getCharacterData(Loc);
2230     const char *startBuf = endBuf;
2231     while (*startBuf != ';' && *startBuf != '<' && startBuf != MainFileStart)
2232       startBuf--; // scan backward (from the decl location) for return type.
2233     const char *startRef = nullptr, *endRef = nullptr;
2234     if (scanForProtocolRefs(startBuf, endBuf, startRef, endRef)) {
2235       // Get the locations of the startRef, endRef.
2236       SourceLocation LessLoc = Loc.getLocWithOffset(startRef-endBuf);
2237       SourceLocation GreaterLoc = Loc.getLocWithOffset(endRef-endBuf+1);
2238       // Comment out the protocol references.
2239       InsertText(LessLoc, "/*");
2240       InsertText(GreaterLoc, "*/");
2241     }
2242   }
2243   if (!proto)
2244       return; // most likely, was a variable
2245   // Now check arguments.
2246   const char *startBuf = SM->getCharacterData(Loc);
2247   const char *startFuncBuf = startBuf;
2248   for (unsigned i = 0; i < proto->getNumParams(); i++) {
2249     if (needToScanForQualifiers(proto->getParamType(i))) {
2250       // Since types are unique, we need to scan the buffer.
2251
2252       const char *endBuf = startBuf;
2253       // scan forward (from the decl location) for argument types.
2254       scanToNextArgument(endBuf);
2255       const char *startRef = nullptr, *endRef = nullptr;
2256       if (scanForProtocolRefs(startBuf, endBuf, startRef, endRef)) {
2257         // Get the locations of the startRef, endRef.
2258         SourceLocation LessLoc =
2259           Loc.getLocWithOffset(startRef-startFuncBuf);
2260         SourceLocation GreaterLoc =
2261           Loc.getLocWithOffset(endRef-startFuncBuf+1);
2262         // Comment out the protocol references.
2263         InsertText(LessLoc, "/*");
2264         InsertText(GreaterLoc, "*/");
2265       }
2266       startBuf = ++endBuf;
2267     }
2268     else {
2269       // If the function name is derived from a macro expansion, then the
2270       // argument buffer will not follow the name. Need to speak with Chris.
2271       while (*startBuf && *startBuf != ')' && *startBuf != ',')
2272         startBuf++; // scan forward (from the decl location) for argument types.
2273       startBuf++;
2274     }
2275   }
2276 }
2277
2278 void RewriteModernObjC::RewriteTypeOfDecl(VarDecl *ND) {
2279   QualType QT = ND->getType();
2280   const Type* TypePtr = QT->getAs<Type>();
2281   if (!isa<TypeOfExprType>(TypePtr))
2282     return;
2283   while (isa<TypeOfExprType>(TypePtr)) {
2284     const TypeOfExprType *TypeOfExprTypePtr = cast<TypeOfExprType>(TypePtr);
2285     QT = TypeOfExprTypePtr->getUnderlyingExpr()->getType();
2286     TypePtr = QT->getAs<Type>();
2287   }
2288   // FIXME. This will not work for multiple declarators; as in:
2289   // __typeof__(a) b,c,d;
2290   std::string TypeAsString(QT.getAsString(Context->getPrintingPolicy()));
2291   SourceLocation DeclLoc = ND->getTypeSpecStartLoc();
2292   const char *startBuf = SM->getCharacterData(DeclLoc);
2293   if (ND->getInit()) {
2294     std::string Name(ND->getNameAsString());
2295     TypeAsString += " " + Name + " = ";
2296     Expr *E = ND->getInit();
2297     SourceLocation startLoc;
2298     if (const CStyleCastExpr *ECE = dyn_cast<CStyleCastExpr>(E))
2299       startLoc = ECE->getLParenLoc();
2300     else
2301       startLoc = E->getBeginLoc();
2302     startLoc = SM->getExpansionLoc(startLoc);
2303     const char *endBuf = SM->getCharacterData(startLoc);
2304     ReplaceText(DeclLoc, endBuf-startBuf-1, TypeAsString);
2305   }
2306   else {
2307     SourceLocation X = ND->getEndLoc();
2308     X = SM->getExpansionLoc(X);
2309     const char *endBuf = SM->getCharacterData(X);
2310     ReplaceText(DeclLoc, endBuf-startBuf-1, TypeAsString);
2311   }
2312 }
2313
2314 // SynthSelGetUidFunctionDecl - SEL sel_registerName(const char *str);
2315 void RewriteModernObjC::SynthSelGetUidFunctionDecl() {
2316   IdentifierInfo *SelGetUidIdent = &Context->Idents.get("sel_registerName");
2317   SmallVector<QualType, 16> ArgTys;
2318   ArgTys.push_back(Context->getPointerType(Context->CharTy.withConst()));
2319   QualType getFuncType =
2320     getSimpleFunctionType(Context->getObjCSelType(), ArgTys);
2321   SelGetUidFunctionDecl = FunctionDecl::Create(*Context, TUDecl,
2322                                                SourceLocation(),
2323                                                SourceLocation(),
2324                                                SelGetUidIdent, getFuncType,
2325                                                nullptr, SC_Extern);
2326 }
2327
2328 void RewriteModernObjC::RewriteFunctionDecl(FunctionDecl *FD) {
2329   // declared in <objc/objc.h>
2330   if (FD->getIdentifier() &&
2331       FD->getName() == "sel_registerName") {
2332     SelGetUidFunctionDecl = FD;
2333     return;
2334   }
2335   RewriteObjCQualifiedInterfaceTypes(FD);
2336 }
2337
2338 void RewriteModernObjC::RewriteBlockPointerType(std::string& Str, QualType Type) {
2339   std::string TypeString(Type.getAsString(Context->getPrintingPolicy()));
2340   const char *argPtr = TypeString.c_str();
2341   if (!strchr(argPtr, '^')) {
2342     Str += TypeString;
2343     return;
2344   }
2345   while (*argPtr) {
2346     Str += (*argPtr == '^' ? '*' : *argPtr);
2347     argPtr++;
2348   }
2349 }
2350
2351 // FIXME. Consolidate this routine with RewriteBlockPointerType.
2352 void RewriteModernObjC::RewriteBlockPointerTypeVariable(std::string& Str,
2353                                                   ValueDecl *VD) {
2354   QualType Type = VD->getType();
2355   std::string TypeString(Type.getAsString(Context->getPrintingPolicy()));
2356   const char *argPtr = TypeString.c_str();
2357   int paren = 0;
2358   while (*argPtr) {
2359     switch (*argPtr) {
2360       case '(':
2361         Str += *argPtr;
2362         paren++;
2363         break;
2364       case ')':
2365         Str += *argPtr;
2366         paren--;
2367         break;
2368       case '^':
2369         Str += '*';
2370         if (paren == 1)
2371           Str += VD->getNameAsString();
2372         break;
2373       default:
2374         Str += *argPtr;
2375         break;
2376     }
2377     argPtr++;
2378   }
2379 }
2380
2381 void RewriteModernObjC::RewriteBlockLiteralFunctionDecl(FunctionDecl *FD) {
2382   SourceLocation FunLocStart = FD->getTypeSpecStartLoc();
2383   const FunctionType *funcType = FD->getType()->getAs<FunctionType>();
2384   const FunctionProtoType *proto = dyn_cast<FunctionProtoType>(funcType);
2385   if (!proto)
2386     return;
2387   QualType Type = proto->getReturnType();
2388   std::string FdStr = Type.getAsString(Context->getPrintingPolicy());
2389   FdStr += " ";
2390   FdStr += FD->getName();
2391   FdStr +=  "(";
2392   unsigned numArgs = proto->getNumParams();
2393   for (unsigned i = 0; i < numArgs; i++) {
2394     QualType ArgType = proto->getParamType(i);
2395   RewriteBlockPointerType(FdStr, ArgType);
2396   if (i+1 < numArgs)
2397     FdStr += ", ";
2398   }
2399   if (FD->isVariadic()) {
2400     FdStr +=  (numArgs > 0) ? ", ...);\n" : "...);\n";
2401   }
2402   else
2403     FdStr +=  ");\n";
2404   InsertText(FunLocStart, FdStr);
2405 }
2406
2407 // SynthSuperConstructorFunctionDecl - id __rw_objc_super(id obj, id super);
2408 void RewriteModernObjC::SynthSuperConstructorFunctionDecl() {
2409   if (SuperConstructorFunctionDecl)
2410     return;
2411   IdentifierInfo *msgSendIdent = &Context->Idents.get("__rw_objc_super");
2412   SmallVector<QualType, 16> ArgTys;
2413   QualType argT = Context->getObjCIdType();
2414   assert(!argT.isNull() && "Can't find 'id' type");
2415   ArgTys.push_back(argT);
2416   ArgTys.push_back(argT);
2417   QualType msgSendType = getSimpleFunctionType(Context->getObjCIdType(),
2418                                                ArgTys);
2419   SuperConstructorFunctionDecl = FunctionDecl::Create(*Context, TUDecl,
2420                                                      SourceLocation(),
2421                                                      SourceLocation(),
2422                                                      msgSendIdent, msgSendType,
2423                                                      nullptr, SC_Extern);
2424 }
2425
2426 // SynthMsgSendFunctionDecl - id objc_msgSend(id self, SEL op, ...);
2427 void RewriteModernObjC::SynthMsgSendFunctionDecl() {
2428   IdentifierInfo *msgSendIdent = &Context->Idents.get("objc_msgSend");
2429   SmallVector<QualType, 16> ArgTys;
2430   QualType argT = Context->getObjCIdType();
2431   assert(!argT.isNull() && "Can't find 'id' type");
2432   ArgTys.push_back(argT);
2433   argT = Context->getObjCSelType();
2434   assert(!argT.isNull() && "Can't find 'SEL' type");
2435   ArgTys.push_back(argT);
2436   QualType msgSendType = getSimpleFunctionType(Context->getObjCIdType(),
2437                                                ArgTys, /*variadic=*/true);
2438   MsgSendFunctionDecl = FunctionDecl::Create(*Context, TUDecl,
2439                                              SourceLocation(),
2440                                              SourceLocation(),
2441                                              msgSendIdent, msgSendType, nullptr,
2442                                              SC_Extern);
2443 }
2444
2445 // SynthMsgSendSuperFunctionDecl - id objc_msgSendSuper(void);
2446 void RewriteModernObjC::SynthMsgSendSuperFunctionDecl() {
2447   IdentifierInfo *msgSendIdent = &Context->Idents.get("objc_msgSendSuper");
2448   SmallVector<QualType, 2> ArgTys;
2449   ArgTys.push_back(Context->VoidTy);
2450   QualType msgSendType = getSimpleFunctionType(Context->getObjCIdType(),
2451                                                ArgTys, /*variadic=*/true);
2452   MsgSendSuperFunctionDecl = FunctionDecl::Create(*Context, TUDecl,
2453                                                   SourceLocation(),
2454                                                   SourceLocation(),
2455                                                   msgSendIdent, msgSendType,
2456                                                   nullptr, SC_Extern);
2457 }
2458
2459 // SynthMsgSendStretFunctionDecl - id objc_msgSend_stret(id self, SEL op, ...);
2460 void RewriteModernObjC::SynthMsgSendStretFunctionDecl() {
2461   IdentifierInfo *msgSendIdent = &Context->Idents.get("objc_msgSend_stret");
2462   SmallVector<QualType, 16> ArgTys;
2463   QualType argT = Context->getObjCIdType();
2464   assert(!argT.isNull() && "Can't find 'id' type");
2465   ArgTys.push_back(argT);
2466   argT = Context->getObjCSelType();
2467   assert(!argT.isNull() && "Can't find 'SEL' type");
2468   ArgTys.push_back(argT);
2469   QualType msgSendType = getSimpleFunctionType(Context->getObjCIdType(),
2470                                                ArgTys, /*variadic=*/true);
2471   MsgSendStretFunctionDecl = FunctionDecl::Create(*Context, TUDecl,
2472                                                   SourceLocation(),
2473                                                   SourceLocation(),
2474                                                   msgSendIdent, msgSendType,
2475                                                   nullptr, SC_Extern);
2476 }
2477
2478 // SynthMsgSendSuperStretFunctionDecl -
2479 // id objc_msgSendSuper_stret(void);
2480 void RewriteModernObjC::SynthMsgSendSuperStretFunctionDecl() {
2481   IdentifierInfo *msgSendIdent =
2482     &Context->Idents.get("objc_msgSendSuper_stret");
2483   SmallVector<QualType, 2> ArgTys;
2484   ArgTys.push_back(Context->VoidTy);
2485   QualType msgSendType = getSimpleFunctionType(Context->getObjCIdType(),
2486                                                ArgTys, /*variadic=*/true);
2487   MsgSendSuperStretFunctionDecl = FunctionDecl::Create(*Context, TUDecl,
2488                                                        SourceLocation(),
2489                                                        SourceLocation(),
2490                                                        msgSendIdent,
2491                                                        msgSendType, nullptr,
2492                                                        SC_Extern);
2493 }
2494
2495 // SynthMsgSendFpretFunctionDecl - double objc_msgSend_fpret(id self, SEL op, ...);
2496 void RewriteModernObjC::SynthMsgSendFpretFunctionDecl() {
2497   IdentifierInfo *msgSendIdent = &Context->Idents.get("objc_msgSend_fpret");
2498   SmallVector<QualType, 16> ArgTys;
2499   QualType argT = Context->getObjCIdType();
2500   assert(!argT.isNull() && "Can't find 'id' type");
2501   ArgTys.push_back(argT);
2502   argT = Context->getObjCSelType();
2503   assert(!argT.isNull() && "Can't find 'SEL' type");
2504   ArgTys.push_back(argT);
2505   QualType msgSendType = getSimpleFunctionType(Context->DoubleTy,
2506                                                ArgTys, /*variadic=*/true);
2507   MsgSendFpretFunctionDecl = FunctionDecl::Create(*Context, TUDecl,
2508                                                   SourceLocation(),
2509                                                   SourceLocation(),
2510                                                   msgSendIdent, msgSendType,
2511                                                   nullptr, SC_Extern);
2512 }
2513
2514 // SynthGetClassFunctionDecl - Class objc_getClass(const char *name);
2515 void RewriteModernObjC::SynthGetClassFunctionDecl() {
2516   IdentifierInfo *getClassIdent = &Context->Idents.get("objc_getClass");
2517   SmallVector<QualType, 16> ArgTys;
2518   ArgTys.push_back(Context->getPointerType(Context->CharTy.withConst()));
2519   QualType getClassType = getSimpleFunctionType(Context->getObjCClassType(),
2520                                                 ArgTys);
2521   GetClassFunctionDecl = FunctionDecl::Create(*Context, TUDecl,
2522                                               SourceLocation(),
2523                                               SourceLocation(),
2524                                               getClassIdent, getClassType,
2525                                               nullptr, SC_Extern);
2526 }
2527
2528 // SynthGetSuperClassFunctionDecl - Class class_getSuperclass(Class cls);
2529 void RewriteModernObjC::SynthGetSuperClassFunctionDecl() {
2530   IdentifierInfo *getSuperClassIdent =
2531     &Context->Idents.get("class_getSuperclass");
2532   SmallVector<QualType, 16> ArgTys;
2533   ArgTys.push_back(Context->getObjCClassType());
2534   QualType getClassType = getSimpleFunctionType(Context->getObjCClassType(),
2535                                                 ArgTys);
2536   GetSuperClassFunctionDecl = FunctionDecl::Create(*Context, TUDecl,
2537                                                    SourceLocation(),
2538                                                    SourceLocation(),
2539                                                    getSuperClassIdent,
2540                                                    getClassType, nullptr,
2541                                                    SC_Extern);
2542 }
2543
2544 // SynthGetMetaClassFunctionDecl - Class objc_getMetaClass(const char *name);
2545 void RewriteModernObjC::SynthGetMetaClassFunctionDecl() {
2546   IdentifierInfo *getClassIdent = &Context->Idents.get("objc_getMetaClass");
2547   SmallVector<QualType, 16> ArgTys;
2548   ArgTys.push_back(Context->getPointerType(Context->CharTy.withConst()));
2549   QualType getClassType = getSimpleFunctionType(Context->getObjCClassType(),
2550                                                 ArgTys);
2551   GetMetaClassFunctionDecl = FunctionDecl::Create(*Context, TUDecl,
2552                                                   SourceLocation(),
2553                                                   SourceLocation(),
2554                                                   getClassIdent, getClassType,
2555                                                   nullptr, SC_Extern);
2556 }
2557
2558 Stmt *RewriteModernObjC::RewriteObjCStringLiteral(ObjCStringLiteral *Exp) {
2559   assert (Exp != nullptr && "Expected non-null ObjCStringLiteral");
2560   QualType strType = getConstantStringStructType();
2561
2562   std::string S = "__NSConstantStringImpl_";
2563
2564   std::string tmpName = InFileName;
2565   unsigned i;
2566   for (i=0; i < tmpName.length(); i++) {
2567     char c = tmpName.at(i);
2568     // replace any non-alphanumeric characters with '_'.
2569     if (!isAlphanumeric(c))
2570       tmpName[i] = '_';
2571   }
2572   S += tmpName;
2573   S += "_";
2574   S += utostr(NumObjCStringLiterals++);
2575
2576   Preamble += "static __NSConstantStringImpl " + S;
2577   Preamble += " __attribute__ ((section (\"__DATA, __cfstring\"))) = {__CFConstantStringClassReference,";
2578   Preamble += "0x000007c8,"; // utf8_str
2579   // The pretty printer for StringLiteral handles escape characters properly.
2580   std::string prettyBufS;
2581   llvm::raw_string_ostream prettyBuf(prettyBufS);
2582   Exp->getString()->printPretty(prettyBuf, nullptr, PrintingPolicy(LangOpts));
2583   Preamble += prettyBuf.str();
2584   Preamble += ",";
2585   Preamble += utostr(Exp->getString()->getByteLength()) + "};\n";
2586
2587   VarDecl *NewVD = VarDecl::Create(*Context, TUDecl, SourceLocation(),
2588                                    SourceLocation(), &Context->Idents.get(S),
2589                                    strType, nullptr, SC_Static);
2590   DeclRefExpr *DRE = new (Context)
2591       DeclRefExpr(*Context, NewVD, false, strType, VK_LValue, SourceLocation());
2592   Expr *Unop = UnaryOperator::Create(
2593       const_cast<ASTContext &>(*Context), DRE, UO_AddrOf,
2594       Context->getPointerType(DRE->getType()), VK_RValue, OK_Ordinary,
2595       SourceLocation(), false, FPOptionsOverride());
2596   // cast to NSConstantString *
2597   CastExpr *cast = NoTypeInfoCStyleCastExpr(Context, Exp->getType(),
2598                                             CK_CPointerToObjCPointerCast, Unop);
2599   ReplaceStmt(Exp, cast);
2600   // delete Exp; leak for now, see RewritePropertyOrImplicitSetter() usage for more info.
2601   return cast;
2602 }
2603
2604 Stmt *RewriteModernObjC::RewriteObjCBoolLiteralExpr(ObjCBoolLiteralExpr *Exp) {
2605   unsigned IntSize =
2606     static_cast<unsigned>(Context->getTypeSize(Context->IntTy));
2607
2608   Expr *FlagExp = IntegerLiteral::Create(*Context,
2609                                          llvm::APInt(IntSize, Exp->getValue()),
2610                                          Context->IntTy, Exp->getLocation());
2611   CastExpr *cast = NoTypeInfoCStyleCastExpr(Context, Context->ObjCBuiltinBoolTy,
2612                                             CK_BitCast, FlagExp);
2613   ParenExpr *PE = new (Context) ParenExpr(Exp->getLocation(), Exp->getExprLoc(),
2614                                           cast);
2615   ReplaceStmt(Exp, PE);
2616   return PE;
2617 }
2618
2619 Stmt *RewriteModernObjC::RewriteObjCBoxedExpr(ObjCBoxedExpr *Exp) {
2620   // synthesize declaration of helper functions needed in this routine.
2621   if (!SelGetUidFunctionDecl)
2622     SynthSelGetUidFunctionDecl();
2623   // use objc_msgSend() for all.
2624   if (!MsgSendFunctionDecl)
2625     SynthMsgSendFunctionDecl();
2626   if (!GetClassFunctionDecl)
2627     SynthGetClassFunctionDecl();
2628
2629   FunctionDecl *MsgSendFlavor = MsgSendFunctionDecl;
2630   SourceLocation StartLoc = Exp->getBeginLoc();
2631   SourceLocation EndLoc = Exp->getEndLoc();
2632
2633   // Synthesize a call to objc_msgSend().
2634   SmallVector<Expr*, 4> MsgExprs;
2635   SmallVector<Expr*, 4> ClsExprs;
2636
2637   // Create a call to objc_getClass("<BoxingClass>"). It will be the 1st argument.
2638   ObjCMethodDecl *BoxingMethod = Exp->getBoxingMethod();
2639   ObjCInterfaceDecl *BoxingClass = BoxingMethod->getClassInterface();
2640
2641   IdentifierInfo *clsName = BoxingClass->getIdentifier();
2642   ClsExprs.push_back(getStringLiteral(clsName->getName()));
2643   CallExpr *Cls = SynthesizeCallToFunctionDecl(GetClassFunctionDecl, ClsExprs,
2644                                                StartLoc, EndLoc);
2645   MsgExprs.push_back(Cls);
2646
2647   // Create a call to sel_registerName("<BoxingMethod>:"), etc.
2648   // it will be the 2nd argument.
2649   SmallVector<Expr*, 4> SelExprs;
2650   SelExprs.push_back(
2651       getStringLiteral(BoxingMethod->getSelector().getAsString()));
2652   CallExpr *SelExp = SynthesizeCallToFunctionDecl(SelGetUidFunctionDecl,
2653                                                   SelExprs, StartLoc, EndLoc);
2654   MsgExprs.push_back(SelExp);
2655
2656   // User provided sub-expression is the 3rd, and last, argument.
2657   Expr *subExpr  = Exp->getSubExpr();
2658   if (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(subExpr)) {
2659     QualType type = ICE->getType();
2660     const Expr *SubExpr = ICE->IgnoreParenImpCasts();
2661     CastKind CK = CK_BitCast;
2662     if (SubExpr->getType()->isIntegralType(*Context) && type->isBooleanType())
2663       CK = CK_IntegralToBoolean;
2664     subExpr = NoTypeInfoCStyleCastExpr(Context, type, CK, subExpr);
2665   }
2666   MsgExprs.push_back(subExpr);
2667
2668   SmallVector<QualType, 4> ArgTypes;
2669   ArgTypes.push_back(Context->getObjCClassType());
2670   ArgTypes.push_back(Context->getObjCSelType());
2671   for (const auto PI : BoxingMethod->parameters())
2672     ArgTypes.push_back(PI->getType());
2673
2674   QualType returnType = Exp->getType();
2675   // Get the type, we will need to reference it in a couple spots.
2676   QualType msgSendType = MsgSendFlavor->getType();
2677
2678   // Create a reference to the objc_msgSend() declaration.
2679   DeclRefExpr *DRE = new (Context) DeclRefExpr(
2680       *Context, MsgSendFlavor, false, msgSendType, VK_LValue, SourceLocation());
2681
2682   CastExpr *cast = NoTypeInfoCStyleCastExpr(
2683       Context, Context->getPointerType(Context->VoidTy), CK_BitCast, DRE);
2684
2685   // Now do the "normal" pointer to function cast.
2686   QualType castType =
2687     getSimpleFunctionType(returnType, ArgTypes, BoxingMethod->isVariadic());
2688   castType = Context->getPointerType(castType);
2689   cast = NoTypeInfoCStyleCastExpr(Context, castType, CK_BitCast,
2690                                   cast);
2691
2692   // Don't forget the parens to enforce the proper binding.
2693   ParenExpr *PE = new (Context) ParenExpr(StartLoc, EndLoc, cast);
2694
2695   auto *FT = msgSendType->castAs<FunctionType>();
2696   CallExpr *CE = CallExpr::Create(*Context, PE, MsgExprs, FT->getReturnType(),
2697                                   VK_RValue, EndLoc, FPOptionsOverride());
2698   ReplaceStmt(Exp, CE);
2699   return CE;
2700 }
2701
2702 Stmt *RewriteModernObjC::RewriteObjCArrayLiteralExpr(ObjCArrayLiteral *Exp) {
2703   // synthesize declaration of helper functions needed in this routine.
2704   if (!SelGetUidFunctionDecl)
2705     SynthSelGetUidFunctionDecl();
2706   // use objc_msgSend() for all.
2707   if (!MsgSendFunctionDecl)
2708     SynthMsgSendFunctionDecl();
2709   if (!GetClassFunctionDecl)
2710     SynthGetClassFunctionDecl();
2711
2712   FunctionDecl *MsgSendFlavor = MsgSendFunctionDecl;
2713   SourceLocation StartLoc = Exp->getBeginLoc();
2714   SourceLocation EndLoc = Exp->getEndLoc();
2715
2716   // Build the expression: __NSContainer_literal(int, ...).arr
2717   QualType IntQT = Context->IntTy;
2718   QualType NSArrayFType =
2719     getSimpleFunctionType(Context->VoidTy, IntQT, true);
2720   std::string NSArrayFName("__NSContainer_literal");
2721   FunctionDecl *NSArrayFD = SynthBlockInitFunctionDecl(NSArrayFName);
2722   DeclRefExpr *NSArrayDRE = new (Context) DeclRefExpr(
2723       *Context, NSArrayFD, false, NSArrayFType, VK_RValue, SourceLocation());
2724
2725   SmallVector<Expr*, 16> InitExprs;
2726   unsigned NumElements = Exp->getNumElements();
2727   unsigned UnsignedIntSize =
2728     static_cast<unsigned>(Context->getTypeSize(Context->UnsignedIntTy));
2729   Expr *count = IntegerLiteral::Create(*Context,
2730                                        llvm::APInt(UnsignedIntSize, NumElements),
2731                                        Context->UnsignedIntTy, SourceLocation());
2732   InitExprs.push_back(count);
2733   for (unsigned i = 0; i < NumElements; i++)
2734     InitExprs.push_back(Exp->getElement(i));
2735   Expr *NSArrayCallExpr =
2736       CallExpr::Create(*Context, NSArrayDRE, InitExprs, NSArrayFType, VK_LValue,
2737                        SourceLocation(), FPOptionsOverride());
2738
2739   FieldDecl *ARRFD = FieldDecl::Create(*Context, nullptr, SourceLocation(),
2740                                     SourceLocation(),
2741                                     &Context->Idents.get("arr"),
2742                                     Context->getPointerType(Context->VoidPtrTy),
2743                                     nullptr, /*BitWidth=*/nullptr,
2744                                     /*Mutable=*/true, ICIS_NoInit);
2745   MemberExpr *ArrayLiteralME =
2746       MemberExpr::CreateImplicit(*Context, NSArrayCallExpr, false, ARRFD,
2747                                  ARRFD->getType(), VK_LValue, OK_Ordinary);
2748   QualType ConstIdT = Context->getObjCIdType().withConst();
2749   CStyleCastExpr * ArrayLiteralObjects =
2750     NoTypeInfoCStyleCastExpr(Context,
2751                              Context->getPointerType(ConstIdT),
2752                              CK_BitCast,
2753                              ArrayLiteralME);
2754
2755   // Synthesize a call to objc_msgSend().
2756   SmallVector<Expr*, 32> MsgExprs;
2757   SmallVector<Expr*, 4> ClsExprs;
2758   QualType expType = Exp->getType();
2759
2760   // Create a call to objc_getClass("NSArray"). It will be th 1st argument.
2761   ObjCInterfaceDecl *Class =
2762     expType->getPointeeType()->castAs<ObjCObjectType>()->getInterface();
2763
2764   IdentifierInfo *clsName = Class->getIdentifier();
2765   ClsExprs.push_back(getStringLiteral(clsName->getName()));
2766   CallExpr *Cls = SynthesizeCallToFunctionDecl(GetClassFunctionDecl, ClsExprs,
2767                                                StartLoc, EndLoc);
2768   MsgExprs.push_back(Cls);
2769
2770   // Create a call to sel_registerName("arrayWithObjects:count:").
2771   // it will be the 2nd argument.
2772   SmallVector<Expr*, 4> SelExprs;
2773   ObjCMethodDecl *ArrayMethod = Exp->getArrayWithObjectsMethod();
2774   SelExprs.push_back(
2775       getStringLiteral(ArrayMethod->getSelector().getAsString()));
2776   CallExpr *SelExp = SynthesizeCallToFunctionDecl(SelGetUidFunctionDecl,
2777                                                   SelExprs, StartLoc, EndLoc);
2778   MsgExprs.push_back(SelExp);
2779
2780   // (const id [])objects
2781   MsgExprs.push_back(ArrayLiteralObjects);
2782
2783   // (NSUInteger)cnt
2784   Expr *cnt = IntegerLiteral::Create(*Context,
2785                                      llvm::APInt(UnsignedIntSize, NumElements),
2786                                      Context->UnsignedIntTy, SourceLocation());
2787   MsgExprs.push_back(cnt);
2788
2789   SmallVector<QualType, 4> ArgTypes;
2790   ArgTypes.push_back(Context->getObjCClassType());
2791   ArgTypes.push_back(Context->getObjCSelType());
2792   for (const auto *PI : ArrayMethod->parameters())
2793     ArgTypes.push_back(PI->getType());
2794
2795   QualType returnType = Exp->getType();
2796   // Get the type, we will need to reference it in a couple spots.
2797   QualType msgSendType = MsgSendFlavor->getType();
2798
2799   // Create a reference to the objc_msgSend() declaration.
2800   DeclRefExpr *DRE = new (Context) DeclRefExpr(
2801       *Context, MsgSendFlavor, false, msgSendType, VK_LValue, SourceLocation());
2802
2803   CastExpr *cast = NoTypeInfoCStyleCastExpr(
2804       Context, Context->getPointerType(Context->VoidTy), CK_BitCast, DRE);
2805
2806   // Now do the "normal" pointer to function cast.
2807   QualType castType =
2808   getSimpleFunctionType(returnType, ArgTypes, ArrayMethod->isVariadic());
2809   castType = Context->getPointerType(castType);
2810   cast = NoTypeInfoCStyleCastExpr(Context, castType, CK_BitCast,
2811                                   cast);
2812
2813   // Don't forget the parens to enforce the proper binding.
2814   ParenExpr *PE = new (Context) ParenExpr(StartLoc, EndLoc, cast);
2815
2816   const FunctionType *FT = msgSendType->castAs<FunctionType>();
2817   CallExpr *CE = CallExpr::Create(*Context, PE, MsgExprs, FT->getReturnType(),
2818                                   VK_RValue, EndLoc, FPOptionsOverride());
2819   ReplaceStmt(Exp, CE);
2820   return CE;
2821 }
2822
2823 Stmt *RewriteModernObjC::RewriteObjCDictionaryLiteralExpr(ObjCDictionaryLiteral *Exp) {
2824   // synthesize declaration of helper functions needed in this routine.
2825   if (!SelGetUidFunctionDecl)
2826     SynthSelGetUidFunctionDecl();
2827   // use objc_msgSend() for all.
2828   if (!MsgSendFunctionDecl)
2829     SynthMsgSendFunctionDecl();
2830   if (!GetClassFunctionDecl)
2831     SynthGetClassFunctionDecl();
2832
2833   FunctionDecl *MsgSendFlavor = MsgSendFunctionDecl;
2834   SourceLocation StartLoc = Exp->getBeginLoc();
2835   SourceLocation EndLoc = Exp->getEndLoc();
2836
2837   // Build the expression: __NSContainer_literal(int, ...).arr
2838   QualType IntQT = Context->IntTy;
2839   QualType NSDictFType =
2840     getSimpleFunctionType(Context->VoidTy, IntQT, true);
2841   std::string NSDictFName("__NSContainer_literal");
2842   FunctionDecl *NSDictFD = SynthBlockInitFunctionDecl(NSDictFName);
2843   DeclRefExpr *NSDictDRE = new (Context) DeclRefExpr(
2844       *Context, NSDictFD, false, NSDictFType, VK_RValue, SourceLocation());
2845
2846   SmallVector<Expr*, 16> KeyExprs;
2847   SmallVector<Expr*, 16> ValueExprs;
2848
2849   unsigned NumElements = Exp->getNumElements();
2850   unsigned UnsignedIntSize =
2851     static_cast<unsigned>(Context->getTypeSize(Context->UnsignedIntTy));
2852   Expr *count = IntegerLiteral::Create(*Context,
2853                                        llvm::APInt(UnsignedIntSize, NumElements),
2854                                        Context->UnsignedIntTy, SourceLocation());
2855   KeyExprs.push_back(count);
2856   ValueExprs.push_back(count);
2857   for (unsigned i = 0; i < NumElements; i++) {
2858     ObjCDictionaryElement Element = Exp->getKeyValueElement(i);
2859     KeyExprs.push_back(Element.Key);
2860     ValueExprs.push_back(Element.Value);
2861   }
2862
2863   // (const id [])objects
2864   Expr *NSValueCallExpr =
2865       CallExpr::Create(*Context, NSDictDRE, ValueExprs, NSDictFType, VK_LValue,
2866                        SourceLocation(), FPOptionsOverride());
2867
2868   FieldDecl *ARRFD = FieldDecl::Create(*Context, nullptr, SourceLocation(),
2869                                        SourceLocation(),
2870                                        &Context->Idents.get("arr"),
2871                                        Context->getPointerType(Context->VoidPtrTy),
2872                                        nullptr, /*BitWidth=*/nullptr,
2873                                        /*Mutable=*/true, ICIS_NoInit);
2874   MemberExpr *DictLiteralValueME =
2875       MemberExpr::CreateImplicit(*Context, NSValueCallExpr, false, ARRFD,
2876                                  ARRFD->getType(), VK_LValue, OK_Ordinary);
2877   QualType ConstIdT = Context->getObjCIdType().withConst();
2878   CStyleCastExpr * DictValueObjects =
2879     NoTypeInfoCStyleCastExpr(Context,
2880                              Context->getPointerType(ConstIdT),
2881                              CK_BitCast,
2882                              DictLiteralValueME);
2883   // (const id <NSCopying> [])keys
2884   Expr *NSKeyCallExpr =
2885       CallExpr::Create(*Context, NSDictDRE, KeyExprs, NSDictFType, VK_LValue,
2886                        SourceLocation(), FPOptionsOverride());
2887
2888   MemberExpr *DictLiteralKeyME =
2889       MemberExpr::CreateImplicit(*Context, NSKeyCallExpr, false, ARRFD,
2890                                  ARRFD->getType(), VK_LValue, OK_Ordinary);
2891
2892   CStyleCastExpr * DictKeyObjects =
2893     NoTypeInfoCStyleCastExpr(Context,
2894                              Context->getPointerType(ConstIdT),
2895                              CK_BitCast,
2896                              DictLiteralKeyME);
2897
2898   // Synthesize a call to objc_msgSend().
2899   SmallVector<Expr*, 32> MsgExprs;
2900   SmallVector<Expr*, 4> ClsExprs;
2901   QualType expType = Exp->getType();
2902
2903   // Create a call to objc_getClass("NSArray"). It will be th 1st argument.
2904   ObjCInterfaceDecl *Class =
2905   expType->getPointeeType()->castAs<ObjCObjectType>()->getInterface();
2906
2907   IdentifierInfo *clsName = Class->getIdentifier();
2908   ClsExprs.push_back(getStringLiteral(clsName->getName()));
2909   CallExpr *Cls = SynthesizeCallToFunctionDecl(GetClassFunctionDecl, ClsExprs,
2910                                                StartLoc, EndLoc);
2911   MsgExprs.push_back(Cls);
2912
2913   // Create a call to sel_registerName("arrayWithObjects:count:").
2914   // it will be the 2nd argument.
2915   SmallVector<Expr*, 4> SelExprs;
2916   ObjCMethodDecl *DictMethod = Exp->getDictWithObjectsMethod();
2917   SelExprs.push_back(getStringLiteral(DictMethod->getSelector().getAsString()));
2918   CallExpr *SelExp = SynthesizeCallToFunctionDecl(SelGetUidFunctionDecl,
2919                                                   SelExprs, StartLoc, EndLoc);
2920   MsgExprs.push_back(SelExp);
2921
2922   // (const id [])objects
2923   MsgExprs.push_back(DictValueObjects);
2924
2925   // (const id <NSCopying> [])keys
2926   MsgExprs.push_back(DictKeyObjects);
2927
2928   // (NSUInteger)cnt
2929   Expr *cnt = IntegerLiteral::Create(*Context,
2930                                      llvm::APInt(UnsignedIntSize, NumElements),
2931                                      Context->UnsignedIntTy, SourceLocation());
2932   MsgExprs.push_back(cnt);
2933
2934   SmallVector<QualType, 8> ArgTypes;
2935   ArgTypes.push_back(Context->getObjCClassType());
2936   ArgTypes.push_back(Context->getObjCSelType());
2937   for (const auto *PI : DictMethod->parameters()) {
2938     QualType T = PI->getType();
2939     if (const PointerType* PT = T->getAs<PointerType>()) {
2940       QualType PointeeTy = PT->getPointeeType();
2941       convertToUnqualifiedObjCType(PointeeTy);
2942       T = Context->getPointerType(PointeeTy);
2943     }
2944     ArgTypes.push_back(T);
2945   }
2946
2947   QualType returnType = Exp->getType();
2948   // Get the type, we will need to reference it in a couple spots.
2949   QualType msgSendType = MsgSendFlavor->getType();
2950
2951   // Create a reference to the objc_msgSend() declaration.
2952   DeclRefExpr *DRE = new (Context) DeclRefExpr(
2953       *Context, MsgSendFlavor, false, msgSendType, VK_LValue, SourceLocation());
2954
2955   CastExpr *cast = NoTypeInfoCStyleCastExpr(
2956       Context, Context->getPointerType(Context->VoidTy), CK_BitCast, DRE);
2957
2958   // Now do the "normal" pointer to function cast.
2959   QualType castType =
2960   getSimpleFunctionType(returnType, ArgTypes, DictMethod->isVariadic());
2961   castType = Context->getPointerType(castType);
2962   cast = NoTypeInfoCStyleCastExpr(Context, castType, CK_BitCast,
2963                                   cast);
2964
2965   // Don't forget the parens to enforce the proper binding.
2966   ParenExpr *PE = new (Context) ParenExpr(StartLoc, EndLoc, cast);
2967
2968   const FunctionType *FT = msgSendType->castAs<FunctionType>();
2969   CallExpr *CE = CallExpr::Create(*Context, PE, MsgExprs, FT->getReturnType(),
2970                                   VK_RValue, EndLoc, FPOptionsOverride());
2971   ReplaceStmt(Exp, CE);
2972   return CE;
2973 }
2974
2975 // struct __rw_objc_super {
2976 //   struct objc_object *object; struct objc_object *superClass;
2977 // };
2978 QualType RewriteModernObjC::getSuperStructType() {
2979   if (!SuperStructDecl) {
2980     SuperStructDecl = RecordDecl::Create(*Context, TTK_Struct, TUDecl,
2981                                          SourceLocation(), SourceLocation(),
2982                                          &Context->Idents.get("__rw_objc_super"));
2983     QualType FieldTypes[2];
2984
2985     // struct objc_object *object;
2986     FieldTypes[0] = Context->getObjCIdType();
2987     // struct objc_object *superClass;
2988     FieldTypes[1] = Context->getObjCIdType();
2989
2990     // Create fields
2991     for (unsigned i = 0; i < 2; ++i) {
2992       SuperStructDecl->addDecl(FieldDecl::Create(*Context, SuperStructDecl,
2993                                                  SourceLocation(),
2994                                                  SourceLocation(), nullptr,
2995                                                  FieldTypes[i], nullptr,
2996                                                  /*BitWidth=*/nullptr,
2997                                                  /*Mutable=*/false,
2998                                                  ICIS_NoInit));
2999     }
3000
3001     SuperStructDecl->completeDefinition();
3002   }
3003   return Context->getTagDeclType(SuperStructDecl);
3004 }
3005
3006 QualType RewriteModernObjC::getConstantStringStructType() {
3007   if (!ConstantStringDecl) {
3008     ConstantStringDecl = RecordDecl::Create(*Context, TTK_Struct, TUDecl,
3009                                             SourceLocation(), SourceLocation(),
3010                          &Context->Idents.get("__NSConstantStringImpl"));
3011     QualType FieldTypes[4];
3012
3013     // struct objc_object *receiver;
3014     FieldTypes[0] = Context->getObjCIdType();
3015     // int flags;
3016     FieldTypes[1] = Context->IntTy;
3017     // char *str;
3018     FieldTypes[2] = Context->getPointerType(Context->CharTy);
3019     // long length;
3020     FieldTypes[3] = Context->LongTy;
3021
3022     // Create fields
3023     for (unsigned i = 0; i < 4; ++i) {
3024       ConstantStringDecl->addDecl(FieldDecl::Create(*Context,
3025                                                     ConstantStringDecl,
3026                                                     SourceLocation(),
3027                                                     SourceLocation(), nullptr,
3028                                                     FieldTypes[i], nullptr,
3029                                                     /*BitWidth=*/nullptr,
3030                                                     /*Mutable=*/true,
3031                                                     ICIS_NoInit));
3032     }
3033
3034     ConstantStringDecl->completeDefinition();
3035   }
3036   return Context->getTagDeclType(ConstantStringDecl);
3037 }
3038
3039 /// getFunctionSourceLocation - returns start location of a function
3040 /// definition. Complication arises when function has declared as
3041 /// extern "C" or extern "C" {...}
3042 static SourceLocation getFunctionSourceLocation (RewriteModernObjC &R,
3043                                                  FunctionDecl *FD) {
3044   if (FD->isExternC()  && !FD->isMain()) {
3045     const DeclContext *DC = FD->getDeclContext();
3046     if (const LinkageSpecDecl *LSD = dyn_cast<LinkageSpecDecl>(DC))
3047       // if it is extern "C" {...}, return function decl's own location.
3048       if (!LSD->getRBraceLoc().isValid())
3049         return LSD->getExternLoc();
3050   }
3051   if (FD->getStorageClass() != SC_None)
3052     R.RewriteBlockLiteralFunctionDecl(FD);
3053   return FD->getTypeSpecStartLoc();
3054 }
3055
3056 void RewriteModernObjC::RewriteLineDirective(const Decl *D) {
3057
3058   SourceLocation Location = D->getLocation();
3059
3060   if (Location.isFileID() && GenerateLineInfo) {
3061     std::string LineString("\n#line ");
3062     PresumedLoc PLoc = SM->getPresumedLoc(Location);
3063     LineString += utostr(PLoc.getLine());
3064     LineString += " \"";
3065     LineString += Lexer::Stringify(PLoc.getFilename());
3066     if (isa<ObjCMethodDecl>(D))
3067       LineString += "\"";
3068     else LineString += "\"\n";
3069
3070     Location = D->getBeginLoc();
3071     if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
3072       if (FD->isExternC()  && !FD->isMain()) {
3073         const DeclContext *DC = FD->getDeclContext();
3074         if (const LinkageSpecDecl *LSD = dyn_cast<LinkageSpecDecl>(DC))
3075           // if it is extern "C" {...}, return function decl's own location.
3076           if (!LSD->getRBraceLoc().isValid())
3077             Location = LSD->getExternLoc();
3078       }
3079     }
3080     InsertText(Location, LineString);
3081   }
3082 }
3083
3084 /// SynthMsgSendStretCallExpr - This routine translates message expression
3085 /// into a call to objc_msgSend_stret() entry point. Tricky part is that
3086 /// nil check on receiver must be performed before calling objc_msgSend_stret.
3087 /// MsgSendStretFlavor - function declaration objc_msgSend_stret(...)
3088 /// msgSendType - function type of objc_msgSend_stret(...)
3089 /// returnType - Result type of the method being synthesized.
3090 /// ArgTypes - type of the arguments passed to objc_msgSend_stret, starting with receiver type.
3091 /// MsgExprs - list of argument expressions being passed to objc_msgSend_stret,
3092 /// starting with receiver.
3093 /// Method - Method being rewritten.
3094 Expr *RewriteModernObjC::SynthMsgSendStretCallExpr(FunctionDecl *MsgSendStretFlavor,
3095                                                  QualType returnType,
3096                                                  SmallVectorImpl<QualType> &ArgTypes,
3097                                                  SmallVectorImpl<Expr*> &MsgExprs,
3098                                                  ObjCMethodDecl *Method) {
3099   // Now do the "normal" pointer to function cast.
3100   QualType FuncType = getSimpleFunctionType(
3101       returnType, ArgTypes, Method ? Method->isVariadic() : false);
3102   QualType castType = Context->getPointerType(FuncType);
3103
3104   // build type for containing the objc_msgSend_stret object.
3105   static unsigned stretCount=0;
3106   std::string name = "__Stret"; name += utostr(stretCount);
3107   std::string str =
3108     "extern \"C\" void * __cdecl memset(void *_Dst, int _Val, size_t _Size);\n";
3109   str += "namespace {\n";
3110   str += "struct "; str += name;
3111   str += " {\n\t";
3112   str += name;
3113   str += "(id receiver, SEL sel";
3114   for (unsigned i = 2; i < ArgTypes.size(); i++) {
3115     std::string ArgName = "arg"; ArgName += utostr(i);
3116     ArgTypes[i].getAsStringInternal(ArgName, Context->getPrintingPolicy());
3117     str += ", "; str += ArgName;
3118   }
3119   // could be vararg.
3120   for (unsigned i = ArgTypes.size(); i < MsgExprs.size(); i++) {
3121     std::string ArgName = "arg"; ArgName += utostr(i);
3122     MsgExprs[i]->getType().getAsStringInternal(ArgName,
3123                                                Context->getPrintingPolicy());
3124     str += ", "; str += ArgName;
3125   }
3126
3127   str += ") {\n";
3128   str += "\t  unsigned size = sizeof(";
3129   str += returnType.getAsString(Context->getPrintingPolicy()); str += ");\n";
3130
3131   str += "\t  if (size == 1 || size == 2 || size == 4 || size == 8)\n";
3132
3133   str += "\t    s = (("; str += castType.getAsString(Context->getPrintingPolicy());
3134   str += ")(void *)objc_msgSend)(receiver, sel";
3135   for (unsigned i = 2; i < ArgTypes.size(); i++) {
3136     str += ", arg"; str += utostr(i);
3137   }
3138   // could be vararg.
3139   for (unsigned i = ArgTypes.size(); i < MsgExprs.size(); i++) {
3140     str += ", arg"; str += utostr(i);
3141   }
3142   str+= ");\n";
3143
3144   str += "\t  else if (receiver == 0)\n";
3145   str += "\t    memset((void*)&s, 0, sizeof(s));\n";
3146   str += "\t  else\n";
3147
3148   str += "\t    s = (("; str += castType.getAsString(Context->getPrintingPolicy());
3149   str += ")(void *)objc_msgSend_stret)(receiver, sel";
3150   for (unsigned i = 2; i < ArgTypes.size(); i++) {
3151     str += ", arg"; str += utostr(i);
3152   }
3153   // could be vararg.
3154   for (unsigned i = ArgTypes.size(); i < MsgExprs.size(); i++) {
3155     str += ", arg"; str += utostr(i);
3156   }
3157   str += ");\n";
3158
3159   str += "\t}\n";
3160   str += "\t"; str += returnType.getAsString(Context->getPrintingPolicy());
3161   str += " s;\n";
3162   str += "};\n};\n\n";
3163   SourceLocation FunLocStart;
3164   if (CurFunctionDef)
3165     FunLocStart = getFunctionSourceLocation(*this, CurFunctionDef);
3166   else {
3167     assert(CurMethodDef && "SynthMsgSendStretCallExpr - CurMethodDef is null");
3168     FunLocStart = CurMethodDef->getBeginLoc();
3169   }
3170
3171   InsertText(FunLocStart, str);
3172   ++stretCount;
3173
3174   // AST for __Stretn(receiver, args).s;
3175   IdentifierInfo *ID = &Context->Idents.get(name);
3176   FunctionDecl *FD =
3177       FunctionDecl::Create(*Context, TUDecl, SourceLocation(), SourceLocation(),
3178                            ID, FuncType, nullptr, SC_Extern, false, false);
3179   DeclRefExpr *DRE = new (Context)
3180       DeclRefExpr(*Context, FD, false, castType, VK_RValue, SourceLocation());
3181   CallExpr *STCE =
3182       CallExpr::Create(*Context, DRE, MsgExprs, castType, VK_LValue,
3183                        SourceLocation(), FPOptionsOverride());
3184
3185   FieldDecl *FieldD = FieldDecl::Create(*Context, nullptr, SourceLocation(),
3186                                     SourceLocation(),
3187                                     &Context->Idents.get("s"),
3188                                     returnType, nullptr,
3189                                     /*BitWidth=*/nullptr,
3190                                     /*Mutable=*/true, ICIS_NoInit);
3191   MemberExpr *ME = MemberExpr::CreateImplicit(
3192       *Context, STCE, false, FieldD, FieldD->getType(), VK_LValue, OK_Ordinary);
3193
3194   return ME;
3195 }
3196
3197 Stmt *RewriteModernObjC::SynthMessageExpr(ObjCMessageExpr *Exp,
3198                                     SourceLocation StartLoc,
3199                                     SourceLocation EndLoc) {
3200   if (!SelGetUidFunctionDecl)
3201     SynthSelGetUidFunctionDecl();
3202   if (!MsgSendFunctionDecl)
3203     SynthMsgSendFunctionDecl();
3204   if (!MsgSendSuperFunctionDecl)
3205     SynthMsgSendSuperFunctionDecl();
3206   if (!MsgSendStretFunctionDecl)
3207     SynthMsgSendStretFunctionDecl();
3208   if (!MsgSendSuperStretFunctionDecl)
3209     SynthMsgSendSuperStretFunctionDecl();
3210   if (!MsgSendFpretFunctionDecl)
3211     SynthMsgSendFpretFunctionDecl();
3212   if (!GetClassFunctionDecl)
3213     SynthGetClassFunctionDecl();
3214   if (!GetSuperClassFunctionDecl)
3215     SynthGetSuperClassFunctionDecl();
3216   if (!GetMetaClassFunctionDecl)
3217     SynthGetMetaClassFunctionDecl();
3218
3219   // default to objc_msgSend().
3220   FunctionDecl *MsgSendFlavor = MsgSendFunctionDecl;
3221   // May need to use objc_msgSend_stret() as well.
3222   FunctionDecl *MsgSendStretFlavor = nullptr;
3223   if (ObjCMethodDecl *mDecl = Exp->getMethodDecl()) {
3224     QualType resultType = mDecl->getReturnType();
3225     if (resultType->isRecordType())
3226       MsgSendStretFlavor = MsgSendStretFunctionDecl;
3227     else if (resultType->isRealFloatingType())
3228       MsgSendFlavor = MsgSendFpretFunctionDecl;
3229   }
3230
3231   // Synthesize a call to objc_msgSend().
3232   SmallVector<Expr*, 8> MsgExprs;
3233   switch (Exp->getReceiverKind()) {
3234   case ObjCMessageExpr::SuperClass: {
3235     MsgSendFlavor = MsgSendSuperFunctionDecl;
3236     if (MsgSendStretFlavor)
3237       MsgSendStretFlavor = MsgSendSuperStretFunctionDecl;
3238     assert(MsgSendFlavor && "MsgSendFlavor is NULL!");
3239
3240     ObjCInterfaceDecl *ClassDecl = CurMethodDef->getClassInterface();
3241
3242     SmallVector<Expr*, 4> InitExprs;
3243
3244     // set the receiver to self, the first argument to all methods.
3245     InitExprs.push_back(
3246       NoTypeInfoCStyleCastExpr(Context, Context->getObjCIdType(),
3247                                CK_BitCast,
3248                    new (Context) DeclRefExpr(*Context,
3249                                              CurMethodDef->getSelfDecl(),
3250                                              false,
3251                                              Context->getObjCIdType(),
3252                                              VK_RValue,
3253                                              SourceLocation()))
3254                         ); // set the 'receiver'.
3255
3256     // (id)class_getSuperclass((Class)objc_getClass("CurrentClass"))
3257     SmallVector<Expr*, 8> ClsExprs;
3258     ClsExprs.push_back(getStringLiteral(ClassDecl->getIdentifier()->getName()));
3259     // (Class)objc_getClass("CurrentClass")
3260     CallExpr *Cls = SynthesizeCallToFunctionDecl(GetMetaClassFunctionDecl,
3261                                                  ClsExprs, StartLoc, EndLoc);
3262     ClsExprs.clear();
3263     ClsExprs.push_back(Cls);
3264     Cls = SynthesizeCallToFunctionDecl(GetSuperClassFunctionDecl, ClsExprs,
3265                                        StartLoc, EndLoc);
3266
3267     // (id)class_getSuperclass((Class)objc_getClass("CurrentClass"))
3268     // To turn off a warning, type-cast to 'id'
3269     InitExprs.push_back( // set 'super class', using class_getSuperclass().
3270                         NoTypeInfoCStyleCastExpr(Context,
3271                                                  Context->getObjCIdType(),
3272                          &n