dd2a204076a40ba69d49dd05f2a39b89bfdde7ee
[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(
2322       *Context, TUDecl, SourceLocation(), SourceLocation(), SelGetUidIdent,
2323       getFuncType, nullptr, StorageClass::Extern);
2324 }
2325
2326 void RewriteModernObjC::RewriteFunctionDecl(FunctionDecl *FD) {
2327   // declared in <objc/objc.h>
2328   if (FD->getIdentifier() &&
2329       FD->getName() == "sel_registerName") {
2330     SelGetUidFunctionDecl = FD;
2331     return;
2332   }
2333   RewriteObjCQualifiedInterfaceTypes(FD);
2334 }
2335
2336 void RewriteModernObjC::RewriteBlockPointerType(std::string& Str, QualType Type) {
2337   std::string TypeString(Type.getAsString(Context->getPrintingPolicy()));
2338   const char *argPtr = TypeString.c_str();
2339   if (!strchr(argPtr, '^')) {
2340     Str += TypeString;
2341     return;
2342   }
2343   while (*argPtr) {
2344     Str += (*argPtr == '^' ? '*' : *argPtr);
2345     argPtr++;
2346   }
2347 }
2348
2349 // FIXME. Consolidate this routine with RewriteBlockPointerType.
2350 void RewriteModernObjC::RewriteBlockPointerTypeVariable(std::string& Str,
2351                                                   ValueDecl *VD) {
2352   QualType Type = VD->getType();
2353   std::string TypeString(Type.getAsString(Context->getPrintingPolicy()));
2354   const char *argPtr = TypeString.c_str();
2355   int paren = 0;
2356   while (*argPtr) {
2357     switch (*argPtr) {
2358       case '(':
2359         Str += *argPtr;
2360         paren++;
2361         break;
2362       case ')':
2363         Str += *argPtr;
2364         paren--;
2365         break;
2366       case '^':
2367         Str += '*';
2368         if (paren == 1)
2369           Str += VD->getNameAsString();
2370         break;
2371       default:
2372         Str += *argPtr;
2373         break;
2374     }
2375     argPtr++;
2376   }
2377 }
2378
2379 void RewriteModernObjC::RewriteBlockLiteralFunctionDecl(FunctionDecl *FD) {
2380   SourceLocation FunLocStart = FD->getTypeSpecStartLoc();
2381   const FunctionType *funcType = FD->getType()->getAs<FunctionType>();
2382   const FunctionProtoType *proto = dyn_cast<FunctionProtoType>(funcType);
2383   if (!proto)
2384     return;
2385   QualType Type = proto->getReturnType();
2386   std::string FdStr = Type.getAsString(Context->getPrintingPolicy());
2387   FdStr += " ";
2388   FdStr += FD->getName();
2389   FdStr +=  "(";
2390   unsigned numArgs = proto->getNumParams();
2391   for (unsigned i = 0; i < numArgs; i++) {
2392     QualType ArgType = proto->getParamType(i);
2393   RewriteBlockPointerType(FdStr, ArgType);
2394   if (i+1 < numArgs)
2395     FdStr += ", ";
2396   }
2397   if (FD->isVariadic()) {
2398     FdStr +=  (numArgs > 0) ? ", ...);\n" : "...);\n";
2399   }
2400   else
2401     FdStr +=  ");\n";
2402   InsertText(FunLocStart, FdStr);
2403 }
2404
2405 // SynthSuperConstructorFunctionDecl - id __rw_objc_super(id obj, id super);
2406 void RewriteModernObjC::SynthSuperConstructorFunctionDecl() {
2407   if (SuperConstructorFunctionDecl)
2408     return;
2409   IdentifierInfo *msgSendIdent = &Context->Idents.get("__rw_objc_super");
2410   SmallVector<QualType, 16> ArgTys;
2411   QualType argT = Context->getObjCIdType();
2412   assert(!argT.isNull() && "Can't find 'id' type");
2413   ArgTys.push_back(argT);
2414   ArgTys.push_back(argT);
2415   QualType msgSendType = getSimpleFunctionType(Context->getObjCIdType(),
2416                                                ArgTys);
2417   SuperConstructorFunctionDecl = FunctionDecl::Create(
2418       *Context, TUDecl, SourceLocation(), SourceLocation(), msgSendIdent,
2419       msgSendType, nullptr, StorageClass::Extern);
2420 }
2421
2422 // SynthMsgSendFunctionDecl - id objc_msgSend(id self, SEL op, ...);
2423 void RewriteModernObjC::SynthMsgSendFunctionDecl() {
2424   IdentifierInfo *msgSendIdent = &Context->Idents.get("objc_msgSend");
2425   SmallVector<QualType, 16> ArgTys;
2426   QualType argT = Context->getObjCIdType();
2427   assert(!argT.isNull() && "Can't find 'id' type");
2428   ArgTys.push_back(argT);
2429   argT = Context->getObjCSelType();
2430   assert(!argT.isNull() && "Can't find 'SEL' type");
2431   ArgTys.push_back(argT);
2432   QualType msgSendType = getSimpleFunctionType(Context->getObjCIdType(),
2433                                                ArgTys, /*variadic=*/true);
2434   MsgSendFunctionDecl = FunctionDecl::Create(
2435       *Context, TUDecl, SourceLocation(), SourceLocation(), msgSendIdent,
2436       msgSendType, nullptr, StorageClass::Extern);
2437 }
2438
2439 // SynthMsgSendSuperFunctionDecl - id objc_msgSendSuper(void);
2440 void RewriteModernObjC::SynthMsgSendSuperFunctionDecl() {
2441   IdentifierInfo *msgSendIdent = &Context->Idents.get("objc_msgSendSuper");
2442   SmallVector<QualType, 2> ArgTys;
2443   ArgTys.push_back(Context->VoidTy);
2444   QualType msgSendType = getSimpleFunctionType(Context->getObjCIdType(),
2445                                                ArgTys, /*variadic=*/true);
2446   MsgSendSuperFunctionDecl = FunctionDecl::Create(
2447       *Context, TUDecl, SourceLocation(), SourceLocation(), msgSendIdent,
2448       msgSendType, nullptr, StorageClass::Extern);
2449 }
2450
2451 // SynthMsgSendStretFunctionDecl - id objc_msgSend_stret(id self, SEL op, ...);
2452 void RewriteModernObjC::SynthMsgSendStretFunctionDecl() {
2453   IdentifierInfo *msgSendIdent = &Context->Idents.get("objc_msgSend_stret");
2454   SmallVector<QualType, 16> ArgTys;
2455   QualType argT = Context->getObjCIdType();
2456   assert(!argT.isNull() && "Can't find 'id' type");
2457   ArgTys.push_back(argT);
2458   argT = Context->getObjCSelType();
2459   assert(!argT.isNull() && "Can't find 'SEL' type");
2460   ArgTys.push_back(argT);
2461   QualType msgSendType = getSimpleFunctionType(Context->getObjCIdType(),
2462                                                ArgTys, /*variadic=*/true);
2463   MsgSendStretFunctionDecl = FunctionDecl::Create(
2464       *Context, TUDecl, SourceLocation(), SourceLocation(), msgSendIdent,
2465       msgSendType, nullptr, StorageClass::Extern);
2466 }
2467
2468 // SynthMsgSendSuperStretFunctionDecl -
2469 // id objc_msgSendSuper_stret(void);
2470 void RewriteModernObjC::SynthMsgSendSuperStretFunctionDecl() {
2471   IdentifierInfo *msgSendIdent =
2472     &Context->Idents.get("objc_msgSendSuper_stret");
2473   SmallVector<QualType, 2> ArgTys;
2474   ArgTys.push_back(Context->VoidTy);
2475   QualType msgSendType = getSimpleFunctionType(Context->getObjCIdType(),
2476                                                ArgTys, /*variadic=*/true);
2477   MsgSendSuperStretFunctionDecl = FunctionDecl::Create(
2478       *Context, TUDecl, SourceLocation(), SourceLocation(), msgSendIdent,
2479       msgSendType, nullptr, StorageClass::Extern);
2480 }
2481
2482 // SynthMsgSendFpretFunctionDecl - double objc_msgSend_fpret(id self, SEL op, ...);
2483 void RewriteModernObjC::SynthMsgSendFpretFunctionDecl() {
2484   IdentifierInfo *msgSendIdent = &Context->Idents.get("objc_msgSend_fpret");
2485   SmallVector<QualType, 16> ArgTys;
2486   QualType argT = Context->getObjCIdType();
2487   assert(!argT.isNull() && "Can't find 'id' type");
2488   ArgTys.push_back(argT);
2489   argT = Context->getObjCSelType();
2490   assert(!argT.isNull() && "Can't find 'SEL' type");
2491   ArgTys.push_back(argT);
2492   QualType msgSendType = getSimpleFunctionType(Context->DoubleTy,
2493                                                ArgTys, /*variadic=*/true);
2494   MsgSendFpretFunctionDecl = FunctionDecl::Create(
2495       *Context, TUDecl, SourceLocation(), SourceLocation(), msgSendIdent,
2496       msgSendType, nullptr, StorageClass::Extern);
2497 }
2498
2499 // SynthGetClassFunctionDecl - Class objc_getClass(const char *name);
2500 void RewriteModernObjC::SynthGetClassFunctionDecl() {
2501   IdentifierInfo *getClassIdent = &Context->Idents.get("objc_getClass");
2502   SmallVector<QualType, 16> ArgTys;
2503   ArgTys.push_back(Context->getPointerType(Context->CharTy.withConst()));
2504   QualType getClassType = getSimpleFunctionType(Context->getObjCClassType(),
2505                                                 ArgTys);
2506   GetClassFunctionDecl = FunctionDecl::Create(
2507       *Context, TUDecl, SourceLocation(), SourceLocation(), getClassIdent,
2508       getClassType, nullptr, StorageClass::Extern);
2509 }
2510
2511 // SynthGetSuperClassFunctionDecl - Class class_getSuperclass(Class cls);
2512 void RewriteModernObjC::SynthGetSuperClassFunctionDecl() {
2513   IdentifierInfo *getSuperClassIdent =
2514     &Context->Idents.get("class_getSuperclass");
2515   SmallVector<QualType, 16> ArgTys;
2516   ArgTys.push_back(Context->getObjCClassType());
2517   QualType getClassType = getSimpleFunctionType(Context->getObjCClassType(),
2518                                                 ArgTys);
2519   GetSuperClassFunctionDecl = FunctionDecl::Create(
2520       *Context, TUDecl, SourceLocation(), SourceLocation(), getSuperClassIdent,
2521       getClassType, nullptr, StorageClass::Extern);
2522 }
2523
2524 // SynthGetMetaClassFunctionDecl - Class objc_getMetaClass(const char *name);
2525 void RewriteModernObjC::SynthGetMetaClassFunctionDecl() {
2526   IdentifierInfo *getClassIdent = &Context->Idents.get("objc_getMetaClass");
2527   SmallVector<QualType, 16> ArgTys;
2528   ArgTys.push_back(Context->getPointerType(Context->CharTy.withConst()));
2529   QualType getClassType = getSimpleFunctionType(Context->getObjCClassType(),
2530                                                 ArgTys);
2531   GetMetaClassFunctionDecl = FunctionDecl::Create(
2532       *Context, TUDecl, SourceLocation(), SourceLocation(), getClassIdent,
2533       getClassType, nullptr, StorageClass::Extern);
2534 }
2535
2536 Stmt *RewriteModernObjC::RewriteObjCStringLiteral(ObjCStringLiteral *Exp) {
2537   assert (Exp != nullptr && "Expected non-null ObjCStringLiteral");
2538   QualType strType = getConstantStringStructType();
2539
2540   std::string S = "__NSConstantStringImpl_";
2541
2542   std::string tmpName = InFileName;
2543   unsigned i;
2544   for (i=0; i < tmpName.length(); i++) {
2545     char c = tmpName.at(i);
2546     // replace any non-alphanumeric characters with '_'.
2547     if (!isAlphanumeric(c))
2548       tmpName[i] = '_';
2549   }
2550   S += tmpName;
2551   S += "_";
2552   S += utostr(NumObjCStringLiterals++);
2553
2554   Preamble += "static __NSConstantStringImpl " + S;
2555   Preamble += " __attribute__ ((section (\"__DATA, __cfstring\"))) = {__CFConstantStringClassReference,";
2556   Preamble += "0x000007c8,"; // utf8_str
2557   // The pretty printer for StringLiteral handles escape characters properly.
2558   std::string prettyBufS;
2559   llvm::raw_string_ostream prettyBuf(prettyBufS);
2560   Exp->getString()->printPretty(prettyBuf, nullptr, PrintingPolicy(LangOpts));
2561   Preamble += prettyBuf.str();
2562   Preamble += ",";
2563   Preamble += utostr(Exp->getString()->getByteLength()) + "};\n";
2564
2565   VarDecl *NewVD = VarDecl::Create(*Context, TUDecl, SourceLocation(),
2566                                    SourceLocation(), &Context->Idents.get(S),
2567                                    strType, nullptr, StorageClass::Static);
2568   DeclRefExpr *DRE = new (Context)
2569       DeclRefExpr(*Context, NewVD, false, strType, VK_LValue, SourceLocation());
2570   Expr *Unop = UnaryOperator::Create(
2571       const_cast<ASTContext &>(*Context), DRE, UO_AddrOf,
2572       Context->getPointerType(DRE->getType()), VK_RValue, OK_Ordinary,
2573       SourceLocation(), false, FPOptionsOverride());
2574   // cast to NSConstantString *
2575   CastExpr *cast = NoTypeInfoCStyleCastExpr(Context, Exp->getType(),
2576                                             CK_CPointerToObjCPointerCast, Unop);
2577   ReplaceStmt(Exp, cast);
2578   // delete Exp; leak for now, see RewritePropertyOrImplicitSetter() usage for more info.
2579   return cast;
2580 }
2581
2582 Stmt *RewriteModernObjC::RewriteObjCBoolLiteralExpr(ObjCBoolLiteralExpr *Exp) {
2583   unsigned IntSize =
2584     static_cast<unsigned>(Context->getTypeSize(Context->IntTy));
2585
2586   Expr *FlagExp = IntegerLiteral::Create(*Context,
2587                                          llvm::APInt(IntSize, Exp->getValue()),
2588                                          Context->IntTy, Exp->getLocation());
2589   CastExpr *cast = NoTypeInfoCStyleCastExpr(Context, Context->ObjCBuiltinBoolTy,
2590                                             CK_BitCast, FlagExp);
2591   ParenExpr *PE = new (Context) ParenExpr(Exp->getLocation(), Exp->getExprLoc(),
2592                                           cast);
2593   ReplaceStmt(Exp, PE);
2594   return PE;
2595 }
2596
2597 Stmt *RewriteModernObjC::RewriteObjCBoxedExpr(ObjCBoxedExpr *Exp) {
2598   // synthesize declaration of helper functions needed in this routine.
2599   if (!SelGetUidFunctionDecl)
2600     SynthSelGetUidFunctionDecl();
2601   // use objc_msgSend() for all.
2602   if (!MsgSendFunctionDecl)
2603     SynthMsgSendFunctionDecl();
2604   if (!GetClassFunctionDecl)
2605     SynthGetClassFunctionDecl();
2606
2607   FunctionDecl *MsgSendFlavor = MsgSendFunctionDecl;
2608   SourceLocation StartLoc = Exp->getBeginLoc();
2609   SourceLocation EndLoc = Exp->getEndLoc();
2610
2611   // Synthesize a call to objc_msgSend().
2612   SmallVector<Expr*, 4> MsgExprs;
2613   SmallVector<Expr*, 4> ClsExprs;
2614
2615   // Create a call to objc_getClass("<BoxingClass>"). It will be the 1st argument.
2616   ObjCMethodDecl *BoxingMethod = Exp->getBoxingMethod();
2617   ObjCInterfaceDecl *BoxingClass = BoxingMethod->getClassInterface();
2618
2619   IdentifierInfo *clsName = BoxingClass->getIdentifier();
2620   ClsExprs.push_back(getStringLiteral(clsName->getName()));
2621   CallExpr *Cls = SynthesizeCallToFunctionDecl(GetClassFunctionDecl, ClsExprs,
2622                                                StartLoc, EndLoc);
2623   MsgExprs.push_back(Cls);
2624
2625   // Create a call to sel_registerName("<BoxingMethod>:"), etc.
2626   // it will be the 2nd argument.
2627   SmallVector<Expr*, 4> SelExprs;
2628   SelExprs.push_back(
2629       getStringLiteral(BoxingMethod->getSelector().getAsString()));
2630   CallExpr *SelExp = SynthesizeCallToFunctionDecl(SelGetUidFunctionDecl,
2631                                                   SelExprs, StartLoc, EndLoc);
2632   MsgExprs.push_back(SelExp);
2633
2634   // User provided sub-expression is the 3rd, and last, argument.
2635   Expr *subExpr  = Exp->getSubExpr();
2636   if (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(subExpr)) {
2637     QualType type = ICE->getType();
2638     const Expr *SubExpr = ICE->IgnoreParenImpCasts();
2639     CastKind CK = CK_BitCast;
2640     if (SubExpr->getType()->isIntegralType(*Context) && type->isBooleanType())
2641       CK = CK_IntegralToBoolean;
2642     subExpr = NoTypeInfoCStyleCastExpr(Context, type, CK, subExpr);
2643   }
2644   MsgExprs.push_back(subExpr);
2645
2646   SmallVector<QualType, 4> ArgTypes;
2647   ArgTypes.push_back(Context->getObjCClassType());
2648   ArgTypes.push_back(Context->getObjCSelType());
2649   for (const auto PI : BoxingMethod->parameters())
2650     ArgTypes.push_back(PI->getType());
2651
2652   QualType returnType = Exp->getType();
2653   // Get the type, we will need to reference it in a couple spots.
2654   QualType msgSendType = MsgSendFlavor->getType();
2655
2656   // Create a reference to the objc_msgSend() declaration.
2657   DeclRefExpr *DRE = new (Context) DeclRefExpr(
2658       *Context, MsgSendFlavor, false, msgSendType, VK_LValue, SourceLocation());
2659
2660   CastExpr *cast = NoTypeInfoCStyleCastExpr(
2661       Context, Context->getPointerType(Context->VoidTy), CK_BitCast, DRE);
2662
2663   // Now do the "normal" pointer to function cast.
2664   QualType castType =
2665     getSimpleFunctionType(returnType, ArgTypes, BoxingMethod->isVariadic());
2666   castType = Context->getPointerType(castType);
2667   cast = NoTypeInfoCStyleCastExpr(Context, castType, CK_BitCast,
2668                                   cast);
2669
2670   // Don't forget the parens to enforce the proper binding.
2671   ParenExpr *PE = new (Context) ParenExpr(StartLoc, EndLoc, cast);
2672
2673   auto *FT = msgSendType->castAs<FunctionType>();
2674   CallExpr *CE = CallExpr::Create(*Context, PE, MsgExprs, FT->getReturnType(),
2675                                   VK_RValue, EndLoc, FPOptionsOverride());
2676   ReplaceStmt(Exp, CE);
2677   return CE;
2678 }
2679
2680 Stmt *RewriteModernObjC::RewriteObjCArrayLiteralExpr(ObjCArrayLiteral *Exp) {
2681   // synthesize declaration of helper functions needed in this routine.
2682   if (!SelGetUidFunctionDecl)
2683     SynthSelGetUidFunctionDecl();
2684   // use objc_msgSend() for all.
2685   if (!MsgSendFunctionDecl)
2686     SynthMsgSendFunctionDecl();
2687   if (!GetClassFunctionDecl)
2688     SynthGetClassFunctionDecl();
2689
2690   FunctionDecl *MsgSendFlavor = MsgSendFunctionDecl;
2691   SourceLocation StartLoc = Exp->getBeginLoc();
2692   SourceLocation EndLoc = Exp->getEndLoc();
2693
2694   // Build the expression: __NSContainer_literal(int, ...).arr
2695   QualType IntQT = Context->IntTy;
2696   QualType NSArrayFType =
2697     getSimpleFunctionType(Context->VoidTy, IntQT, true);
2698   std::string NSArrayFName("__NSContainer_literal");
2699   FunctionDecl *NSArrayFD = SynthBlockInitFunctionDecl(NSArrayFName);
2700   DeclRefExpr *NSArrayDRE = new (Context) DeclRefExpr(
2701       *Context, NSArrayFD, false, NSArrayFType, VK_RValue, SourceLocation());
2702
2703   SmallVector<Expr*, 16> InitExprs;
2704   unsigned NumElements = Exp->getNumElements();
2705   unsigned UnsignedIntSize =
2706     static_cast<unsigned>(Context->getTypeSize(Context->UnsignedIntTy));
2707   Expr *count = IntegerLiteral::Create(*Context,
2708                                        llvm::APInt(UnsignedIntSize, NumElements),
2709                                        Context->UnsignedIntTy, SourceLocation());
2710   InitExprs.push_back(count);
2711   for (unsigned i = 0; i < NumElements; i++)
2712     InitExprs.push_back(Exp->getElement(i));
2713   Expr *NSArrayCallExpr =
2714       CallExpr::Create(*Context, NSArrayDRE, InitExprs, NSArrayFType, VK_LValue,
2715                        SourceLocation(), FPOptionsOverride());
2716
2717   FieldDecl *ARRFD = FieldDecl::Create(*Context, nullptr, SourceLocation(),
2718                                     SourceLocation(),
2719                                     &Context->Idents.get("arr"),
2720                                     Context->getPointerType(Context->VoidPtrTy),
2721                                     nullptr, /*BitWidth=*/nullptr,
2722                                     /*Mutable=*/true, ICIS_NoInit);
2723   MemberExpr *ArrayLiteralME =
2724       MemberExpr::CreateImplicit(*Context, NSArrayCallExpr, false, ARRFD,
2725                                  ARRFD->getType(), VK_LValue, OK_Ordinary);
2726   QualType ConstIdT = Context->getObjCIdType().withConst();
2727   CStyleCastExpr * ArrayLiteralObjects =
2728     NoTypeInfoCStyleCastExpr(Context,
2729                              Context->getPointerType(ConstIdT),
2730                              CK_BitCast,
2731                              ArrayLiteralME);
2732
2733   // Synthesize a call to objc_msgSend().
2734   SmallVector<Expr*, 32> MsgExprs;
2735   SmallVector<Expr*, 4> ClsExprs;
2736   QualType expType = Exp->getType();
2737
2738   // Create a call to objc_getClass("NSArray"). It will be th 1st argument.
2739   ObjCInterfaceDecl *Class =
2740     expType->getPointeeType()->castAs<ObjCObjectType>()->getInterface();
2741
2742   IdentifierInfo *clsName = Class->getIdentifier();
2743   ClsExprs.push_back(getStringLiteral(clsName->getName()));
2744   CallExpr *Cls = SynthesizeCallToFunctionDecl(GetClassFunctionDecl, ClsExprs,
2745                                                StartLoc, EndLoc);
2746   MsgExprs.push_back(Cls);
2747
2748   // Create a call to sel_registerName("arrayWithObjects:count:").
2749   // it will be the 2nd argument.
2750   SmallVector<Expr*, 4> SelExprs;
2751   ObjCMethodDecl *ArrayMethod = Exp->getArrayWithObjectsMethod();
2752   SelExprs.push_back(
2753       getStringLiteral(ArrayMethod->getSelector().getAsString()));
2754   CallExpr *SelExp = SynthesizeCallToFunctionDecl(SelGetUidFunctionDecl,
2755                                                   SelExprs, StartLoc, EndLoc);
2756   MsgExprs.push_back(SelExp);
2757
2758   // (const id [])objects
2759   MsgExprs.push_back(ArrayLiteralObjects);
2760
2761   // (NSUInteger)cnt
2762   Expr *cnt = IntegerLiteral::Create(*Context,
2763                                      llvm::APInt(UnsignedIntSize, NumElements),
2764                                      Context->UnsignedIntTy, SourceLocation());
2765   MsgExprs.push_back(cnt);
2766
2767   SmallVector<QualType, 4> ArgTypes;
2768   ArgTypes.push_back(Context->getObjCClassType());
2769   ArgTypes.push_back(Context->getObjCSelType());
2770   for (const auto *PI : ArrayMethod->parameters())
2771     ArgTypes.push_back(PI->getType());
2772
2773   QualType returnType = Exp->getType();
2774   // Get the type, we will need to reference it in a couple spots.
2775   QualType msgSendType = MsgSendFlavor->getType();
2776
2777   // Create a reference to the objc_msgSend() declaration.
2778   DeclRefExpr *DRE = new (Context) DeclRefExpr(
2779       *Context, MsgSendFlavor, false, msgSendType, VK_LValue, SourceLocation());
2780
2781   CastExpr *cast = NoTypeInfoCStyleCastExpr(
2782       Context, Context->getPointerType(Context->VoidTy), CK_BitCast, DRE);
2783
2784   // Now do the "normal" pointer to function cast.
2785   QualType castType =
2786   getSimpleFunctionType(returnType, ArgTypes, ArrayMethod->isVariadic());
2787   castType = Context->getPointerType(castType);
2788   cast = NoTypeInfoCStyleCastExpr(Context, castType, CK_BitCast,
2789                                   cast);
2790
2791   // Don't forget the parens to enforce the proper binding.
2792   ParenExpr *PE = new (Context) ParenExpr(StartLoc, EndLoc, cast);
2793
2794   const FunctionType *FT = msgSendType->castAs<FunctionType>();
2795   CallExpr *CE = CallExpr::Create(*Context, PE, MsgExprs, FT->getReturnType(),
2796                                   VK_RValue, EndLoc, FPOptionsOverride());
2797   ReplaceStmt(Exp, CE);
2798   return CE;
2799 }
2800
2801 Stmt *RewriteModernObjC::RewriteObjCDictionaryLiteralExpr(ObjCDictionaryLiteral *Exp) {
2802   // synthesize declaration of helper functions needed in this routine.
2803   if (!SelGetUidFunctionDecl)
2804     SynthSelGetUidFunctionDecl();
2805   // use objc_msgSend() for all.
2806   if (!MsgSendFunctionDecl)
2807     SynthMsgSendFunctionDecl();
2808   if (!GetClassFunctionDecl)
2809     SynthGetClassFunctionDecl();
2810
2811   FunctionDecl *MsgSendFlavor = MsgSendFunctionDecl;
2812   SourceLocation StartLoc = Exp->getBeginLoc();
2813   SourceLocation EndLoc = Exp->getEndLoc();
2814
2815   // Build the expression: __NSContainer_literal(int, ...).arr
2816   QualType IntQT = Context->IntTy;
2817   QualType NSDictFType =
2818     getSimpleFunctionType(Context->VoidTy, IntQT, true);
2819   std::string NSDictFName("__NSContainer_literal");
2820   FunctionDecl *NSDictFD = SynthBlockInitFunctionDecl(NSDictFName);
2821   DeclRefExpr *NSDictDRE = new (Context) DeclRefExpr(
2822       *Context, NSDictFD, false, NSDictFType, VK_RValue, SourceLocation());
2823
2824   SmallVector<Expr*, 16> KeyExprs;
2825   SmallVector<Expr*, 16> ValueExprs;
2826
2827   unsigned NumElements = Exp->getNumElements();
2828   unsigned UnsignedIntSize =
2829     static_cast<unsigned>(Context->getTypeSize(Context->UnsignedIntTy));
2830   Expr *count = IntegerLiteral::Create(*Context,
2831                                        llvm::APInt(UnsignedIntSize, NumElements),
2832                                        Context->UnsignedIntTy, SourceLocation());
2833   KeyExprs.push_back(count);
2834   ValueExprs.push_back(count);
2835   for (unsigned i = 0; i < NumElements; i++) {
2836     ObjCDictionaryElement Element = Exp->getKeyValueElement(i);
2837     KeyExprs.push_back(Element.Key);
2838     ValueExprs.push_back(Element.Value);
2839   }
2840
2841   // (const id [])objects
2842   Expr *NSValueCallExpr =
2843       CallExpr::Create(*Context, NSDictDRE, ValueExprs, NSDictFType, VK_LValue,
2844                        SourceLocation(), FPOptionsOverride());
2845
2846   FieldDecl *ARRFD = FieldDecl::Create(*Context, nullptr, SourceLocation(),
2847                                        SourceLocation(),
2848                                        &Context->Idents.get("arr"),
2849                                        Context->getPointerType(Context->VoidPtrTy),
2850                                        nullptr, /*BitWidth=*/nullptr,
2851                                        /*Mutable=*/true, ICIS_NoInit);
2852   MemberExpr *DictLiteralValueME =
2853       MemberExpr::CreateImplicit(*Context, NSValueCallExpr, false, ARRFD,
2854                                  ARRFD->getType(), VK_LValue, OK_Ordinary);
2855   QualType ConstIdT = Context->getObjCIdType().withConst();
2856   CStyleCastExpr * DictValueObjects =
2857     NoTypeInfoCStyleCastExpr(Context,
2858                              Context->getPointerType(ConstIdT),
2859                              CK_BitCast,
2860                              DictLiteralValueME);
2861   // (const id <NSCopying> [])keys
2862   Expr *NSKeyCallExpr =
2863       CallExpr::Create(*Context, NSDictDRE, KeyExprs, NSDictFType, VK_LValue,
2864                        SourceLocation(), FPOptionsOverride());
2865
2866   MemberExpr *DictLiteralKeyME =
2867       MemberExpr::CreateImplicit(*Context, NSKeyCallExpr, false, ARRFD,
2868                                  ARRFD->getType(), VK_LValue, OK_Ordinary);
2869
2870   CStyleCastExpr * DictKeyObjects =
2871     NoTypeInfoCStyleCastExpr(Context,
2872                              Context->getPointerType(ConstIdT),
2873                              CK_BitCast,
2874                              DictLiteralKeyME);
2875
2876   // Synthesize a call to objc_msgSend().
2877   SmallVector<Expr*, 32> MsgExprs;
2878   SmallVector<Expr*, 4> ClsExprs;
2879   QualType expType = Exp->getType();
2880
2881   // Create a call to objc_getClass("NSArray"). It will be th 1st argument.
2882   ObjCInterfaceDecl *Class =
2883   expType->getPointeeType()->castAs<ObjCObjectType>()->getInterface();
2884
2885   IdentifierInfo *clsName = Class->getIdentifier();
2886   ClsExprs.push_back(getStringLiteral(clsName->getName()));
2887   CallExpr *Cls = SynthesizeCallToFunctionDecl(GetClassFunctionDecl, ClsExprs,
2888                                                StartLoc, EndLoc);
2889   MsgExprs.push_back(Cls);
2890
2891   // Create a call to sel_registerName("arrayWithObjects:count:").
2892   // it will be the 2nd argument.
2893   SmallVector<Expr*, 4> SelExprs;
2894   ObjCMethodDecl *DictMethod = Exp->getDictWithObjectsMethod();
2895   SelExprs.push_back(getStringLiteral(DictMethod->getSelector().getAsString()));
2896   CallExpr *SelExp = SynthesizeCallToFunctionDecl(SelGetUidFunctionDecl,
2897                                                   SelExprs, StartLoc, EndLoc);
2898   MsgExprs.push_back(SelExp);
2899
2900   // (const id [])objects
2901   MsgExprs.push_back(DictValueObjects);
2902
2903   // (const id <NSCopying> [])keys
2904   MsgExprs.push_back(DictKeyObjects);
2905
2906   // (NSUInteger)cnt
2907   Expr *cnt = IntegerLiteral::Create(*Context,
2908                                      llvm::APInt(UnsignedIntSize, NumElements),
2909                                      Context->UnsignedIntTy, SourceLocation());
2910   MsgExprs.push_back(cnt);
2911
2912   SmallVector<QualType, 8> ArgTypes;
2913   ArgTypes.push_back(Context->getObjCClassType());
2914   ArgTypes.push_back(Context->getObjCSelType());
2915   for (const auto *PI : DictMethod->parameters()) {
2916     QualType T = PI->getType();
2917     if (const PointerType* PT = T->getAs<PointerType>()) {
2918       QualType PointeeTy = PT->getPointeeType();
2919       convertToUnqualifiedObjCType(PointeeTy);
2920       T = Context->getPointerType(PointeeTy);
2921     }
2922     ArgTypes.push_back(T);
2923   }
2924
2925   QualType returnType = Exp->getType();
2926   // Get the type, we will need to reference it in a couple spots.
2927   QualType msgSendType = MsgSendFlavor->getType();
2928
2929   // Create a reference to the objc_msgSend() declaration.
2930   DeclRefExpr *DRE = new (Context) DeclRefExpr(
2931       *Context, MsgSendFlavor, false, msgSendType, VK_LValue, SourceLocation());
2932
2933   CastExpr *cast = NoTypeInfoCStyleCastExpr(
2934       Context, Context->getPointerType(Context->VoidTy), CK_BitCast, DRE);
2935
2936   // Now do the "normal" pointer to function cast.
2937   QualType castType =
2938   getSimpleFunctionType(returnType, ArgTypes, DictMethod->isVariadic());
2939   castType = Context->getPointerType(castType);
2940   cast = NoTypeInfoCStyleCastExpr(Context, castType, CK_BitCast,
2941                                   cast);
2942
2943   // Don't forget the parens to enforce the proper binding.
2944   ParenExpr *PE = new (Context) ParenExpr(StartLoc, EndLoc, cast);
2945
2946   const FunctionType *FT = msgSendType->castAs<FunctionType>();
2947   CallExpr *CE = CallExpr::Create(*Context, PE, MsgExprs, FT->getReturnType(),
2948                                   VK_RValue, EndLoc, FPOptionsOverride());
2949   ReplaceStmt(Exp, CE);
2950   return CE;
2951 }
2952
2953 // struct __rw_objc_super {
2954 //   struct objc_object *object; struct objc_object *superClass;
2955 // };
2956 QualType RewriteModernObjC::getSuperStructType() {
2957   if (!SuperStructDecl) {
2958     SuperStructDecl = RecordDecl::Create(*Context, TTK_Struct, TUDecl,
2959                                          SourceLocation(), SourceLocation(),
2960                                          &Context->Idents.get("__rw_objc_super"));
2961     QualType FieldTypes[2];
2962
2963     // struct objc_object *object;
2964     FieldTypes[0] = Context->getObjCIdType();
2965     // struct objc_object *superClass;
2966     FieldTypes[1] = Context->getObjCIdType();
2967
2968     // Create fields
2969     for (unsigned i = 0; i < 2; ++i) {
2970       SuperStructDecl->addDecl(FieldDecl::Create(*Context, SuperStructDecl,
2971                                                  SourceLocation(),
2972                                                  SourceLocation(), nullptr,
2973                                                  FieldTypes[i], nullptr,
2974                                                  /*BitWidth=*/nullptr,
2975                                                  /*Mutable=*/false,
2976                                                  ICIS_NoInit));
2977     }
2978
2979     SuperStructDecl->completeDefinition();
2980   }
2981   return Context->getTagDeclType(SuperStructDecl);
2982 }
2983
2984 QualType RewriteModernObjC::getConstantStringStructType() {
2985   if (!ConstantStringDecl) {
2986     ConstantStringDecl = RecordDecl::Create(*Context, TTK_Struct, TUDecl,
2987                                             SourceLocation(), SourceLocation(),
2988                          &Context->Idents.get("__NSConstantStringImpl"));
2989     QualType FieldTypes[4];
2990
2991     // struct objc_object *receiver;
2992     FieldTypes[0] = Context->getObjCIdType();
2993     // int flags;
2994     FieldTypes[1] = Context->IntTy;
2995     // char *str;
2996     FieldTypes[2] = Context->getPointerType(Context->CharTy);
2997     // long length;
2998     FieldTypes[3] = Context->LongTy;
2999
3000     // Create fields
3001     for (unsigned i = 0; i < 4; ++i) {
3002       ConstantStringDecl->addDecl(FieldDecl::Create(*Context,
3003                                                     ConstantStringDecl,
3004                                                     SourceLocation(),
3005                                                     SourceLocation(), nullptr,
3006                                                     FieldTypes[i], nullptr,
3007                                                     /*BitWidth=*/nullptr,
3008                                                     /*Mutable=*/true,
3009                                                     ICIS_NoInit));
3010     }
3011
3012     ConstantStringDecl->completeDefinition();
3013   }
3014   return Context->getTagDeclType(ConstantStringDecl);
3015 }
3016
3017 /// getFunctionSourceLocation - returns start location of a function
3018 /// definition. Complication arises when function has declared as
3019 /// extern "C" or extern "C" {...}
3020 static SourceLocation getFunctionSourceLocation (RewriteModernObjC &R,
3021                                                  FunctionDecl *FD) {
3022   if (FD->isExternC()  && !FD->isMain()) {
3023     const DeclContext *DC = FD->getDeclContext();
3024     if (const LinkageSpecDecl *LSD = dyn_cast<LinkageSpecDecl>(DC))
3025       // if it is extern "C" {...}, return function decl's own location.
3026       if (!LSD->getRBraceLoc().isValid())
3027         return LSD->getExternLoc();
3028   }
3029   if (FD->getStorageClass() != StorageClass::None)
3030     R.RewriteBlockLiteralFunctionDecl(FD);
3031   return FD->getTypeSpecStartLoc();
3032 }
3033
3034 void RewriteModernObjC::RewriteLineDirective(const Decl *D) {
3035
3036   SourceLocation Location = D->getLocation();
3037
3038   if (Location.isFileID() && GenerateLineInfo) {
3039     std::string LineString("\n#line ");
3040     PresumedLoc PLoc = SM->getPresumedLoc(Location);
3041     LineString += utostr(PLoc.getLine());
3042     LineString += " \"";
3043     LineString += Lexer::Stringify(PLoc.getFilename());
3044     if (isa<ObjCMethodDecl>(D))
3045       LineString += "\"";
3046     else LineString += "\"\n";
3047
3048     Location = D->getBeginLoc();
3049     if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
3050       if (FD->isExternC()  && !FD->isMain()) {
3051         const DeclContext *DC = FD->getDeclContext();
3052         if (const LinkageSpecDecl *LSD = dyn_cast<LinkageSpecDecl>(DC))
3053           // if it is extern "C" {...}, return function decl's own location.
3054           if (!LSD->getRBraceLoc().isValid())
3055             Location = LSD->getExternLoc();
3056       }
3057     }
3058     InsertText(Location, LineString);
3059   }
3060 }
3061
3062 /// SynthMsgSendStretCallExpr - This routine translates message expression
3063 /// into a call to objc_msgSend_stret() entry point. Tricky part is that
3064 /// nil check on receiver must be performed before calling objc_msgSend_stret.
3065 /// MsgSendStretFlavor - function declaration objc_msgSend_stret(...)
3066 /// msgSendType - function type of objc_msgSend_stret(...)
3067 /// returnType - Result type of the method being synthesized.
3068 /// ArgTypes - type of the arguments passed to objc_msgSend_stret, starting with receiver type.
3069 /// MsgExprs - list of argument expressions being passed to objc_msgSend_stret,
3070 /// starting with receiver.
3071 /// Method - Method being rewritten.
3072 Expr *RewriteModernObjC::SynthMsgSendStretCallExpr(FunctionDecl *MsgSendStretFlavor,
3073                                                  QualType returnType,
3074                                                  SmallVectorImpl<QualType> &ArgTypes,
3075                                                  SmallVectorImpl<Expr*> &MsgExprs,
3076                                                  ObjCMethodDecl *Method) {
3077   // Now do the "normal" pointer to function cast.
3078   QualType FuncType = getSimpleFunctionType(
3079       returnType, ArgTypes, Method ? Method->isVariadic() : false);
3080   QualType castType = Context->getPointerType(FuncType);
3081
3082   // build type for containing the objc_msgSend_stret object.
3083   static unsigned stretCount=0;
3084   std::string name = "__Stret"; name += utostr(stretCount);
3085   std::string str =
3086     "extern \"C\" void * __cdecl memset(void *_Dst, int _Val, size_t _Size);\n";
3087   str += "namespace {\n";
3088   str += "struct "; str += name;
3089   str += " {\n\t";
3090   str += name;
3091   str += "(id receiver, SEL sel";
3092   for (unsigned i = 2; i < ArgTypes.size(); i++) {
3093     std::string ArgName = "arg"; ArgName += utostr(i);
3094     ArgTypes[i].getAsStringInternal(ArgName, Context->getPrintingPolicy());
3095     str += ", "; str += ArgName;
3096   }
3097   // could be vararg.
3098   for (unsigned i = ArgTypes.size(); i < MsgExprs.size(); i++) {
3099     std::string ArgName = "arg"; ArgName += utostr(i);
3100     MsgExprs[i]->getType().getAsStringInternal(ArgName,
3101                                                Context->getPrintingPolicy());
3102     str += ", "; str += ArgName;
3103   }
3104
3105   str += ") {\n";
3106   str += "\t  unsigned size = sizeof(";
3107   str += returnType.getAsString(Context->getPrintingPolicy()); str += ");\n";
3108
3109   str += "\t  if (size == 1 || size == 2 || size == 4 || size == 8)\n";
3110
3111   str += "\t    s = (("; str += castType.getAsString(Context->getPrintingPolicy());
3112   str += ")(void *)objc_msgSend)(receiver, sel";
3113   for (unsigned i = 2; i < ArgTypes.size(); i++) {
3114     str += ", arg"; str += utostr(i);
3115   }
3116   // could be vararg.
3117   for (unsigned i = ArgTypes.size(); i < MsgExprs.size(); i++) {
3118     str += ", arg"; str += utostr(i);
3119   }
3120   str+= ");\n";
3121
3122   str += "\t  else if (receiver == 0)\n";
3123   str += "\t    memset((void*)&s, 0, sizeof(s));\n";
3124   str += "\t  else\n";
3125
3126   str += "\t    s = (("; str += castType.getAsString(Context->getPrintingPolicy());
3127   str += ")(void *)objc_msgSend_stret)(receiver, sel";
3128   for (unsigned i = 2; i < ArgTypes.size(); i++) {
3129     str += ", arg"; str += utostr(i);
3130   }
3131   // could be vararg.
3132   for (unsigned i = ArgTypes.size(); i < MsgExprs.size(); i++) {
3133     str += ", arg"; str += utostr(i);
3134   }
3135   str += ");\n";
3136
3137   str += "\t}\n";
3138   str += "\t"; str += returnType.getAsString(Context->getPrintingPolicy());
3139   str += " s;\n";
3140   str += "};\n};\n\n";
3141   SourceLocation FunLocStart;
3142   if (CurFunctionDef)
3143     FunLocStart = getFunctionSourceLocation(*this, CurFunctionDef);
3144   else {
3145     assert(CurMethodDef && "SynthMsgSendStretCallExpr - CurMethodDef is null");
3146     FunLocStart = CurMethodDef->getBeginLoc();
3147   }
3148
3149   InsertText(FunLocStart, str);
3150   ++stretCount;
3151
3152   // AST for __Stretn(receiver, args).s;
3153   IdentifierInfo *ID = &Context->Idents.get(name);
3154   FunctionDecl *FD = FunctionDecl::Create(
3155       *Context, TUDecl, SourceLocation(), SourceLocation(), ID, FuncType,
3156       nullptr, StorageClass::Extern, false, false);
3157   DeclRefExpr *DRE = new (Context)
3158       DeclRefExpr(*Context, FD, false, castType, VK_RValue, SourceLocation());
3159   CallExpr *STCE =
3160       CallExpr::Create(*Context, DRE, MsgExprs, castType, VK_LValue,
3161                        SourceLocation(), FPOptionsOverride());
3162
3163   FieldDecl *FieldD = FieldDecl::Create(*Context, nullptr, SourceLocation(),
3164                                     SourceLocation(),
3165                                     &Context->Idents.get("s"),
3166                                     returnType, nullptr,
3167                                     /*BitWidth=*/nullptr,
3168                                     /*Mutable=*/true, ICIS_NoInit);
3169   MemberExpr *ME = MemberExpr::CreateImplicit(
3170       *Context, STCE, false, FieldD, FieldD->getType(), VK_LValue, OK_Ordinary);
3171
3172   return ME;
3173 }
3174
3175 Stmt *RewriteModernObjC::SynthMessageExpr(ObjCMessageExpr *Exp,
3176                                     SourceLocation StartLoc,
3177                                     SourceLocation EndLoc) {
3178   if (!SelGetUidFunctionDecl)
3179     SynthSelGetUidFunctionDecl();
3180   if (!MsgSendFunctionDecl)
3181     SynthMsgSendFunctionDecl();
3182   if (!MsgSendSuperFunctionDecl)
3183     SynthMsgSendSuperFunctionDecl();
3184   if (!MsgSendStretFunctionDecl)
3185     SynthMsgSendStretFunctionDecl();
3186   if (!MsgSendSuperStretFunctionDecl)
3187     SynthMsgSendSuperStretFunctionDecl();
3188   if (!MsgSendFpretFunctionDecl)
3189     SynthMsgSendFpretFunctionDecl();
3190   if (!GetClassFunctionDecl)
3191     SynthGetClassFunctionDecl();
3192   if (!GetSuperClassFunctionDecl)
3193     SynthGetSuperClassFunctionDecl();
3194   if (!GetMetaClassFunctionDecl)
3195     SynthGetMetaClassFunctionDecl();
3196
3197   // default to objc_msgSend().
3198   FunctionDecl *MsgSendFlavor = MsgSendFunctionDecl;
3199   // May need to use objc_msgSend_stret() as well.
3200   FunctionDecl *MsgSendStretFlavor = nullptr;
3201   if (ObjCMethodDecl *mDecl = Exp->getMethodDecl()) {
3202     QualType resultType = mDecl->getReturnType();
3203     if (resultType->isRecordType())
3204       MsgSendStretFlavor = MsgSendStretFunctionDecl;
3205     else if (resultType->isRealFloatingType())
3206       MsgSendFlavor = MsgSendFpretFunctionDecl;
3207   }
3208
3209   // Synthesize a call to objc_msgSend().
3210   SmallVector<Expr*, 8> MsgExprs;
3211   switch (Exp->getReceiverKind()) {
3212   case ObjCMessageExpr::SuperClass: {
3213     MsgSendFlavor = MsgSendSuperFunctionDecl;
3214     if (MsgSendStretFlavor)
3215       MsgSendStretFlavor = MsgSendSuperStretFunctionDecl;
3216     assert(MsgSendFlavor && "MsgSendFlavor is NULL!");
3217
3218     ObjCInterfaceDecl *ClassDecl = CurMethodDef->getClassInterface();
3219
3220     SmallVector<Expr*, 4> InitExprs;
3221
3222     // set the receiver to self, the first argument to all methods.
3223     InitExprs.push_back(
3224       NoTypeInfoCStyleCastExpr(Context, Context->getObjCIdType(),
3225                                CK_BitCast,
3226                    new (Context) DeclRefExpr(*Context,
3227                                              CurMethodDef->getSelfDecl(),
3228                                              false,
3229                                              Context->getObjCIdType(),
3230                                              VK_RValue,
3231                                              SourceLocation()))
3232                         ); // set the 'receiver'.
3233
3234     // (id)class_getSuperclass((Class)objc_getClass("CurrentClass"))
3235     SmallVector<Expr*, 8> ClsExprs;
3236     ClsExprs.push_back(getStringLiteral(ClassDecl->getIdentifier()->getName()));
3237     // (Class)objc_getClass("CurrentClass")
3238     CallExpr *Cls = SynthesizeCallToFunctionDecl(GetMetaClassFunctionDecl,
3239                                                  ClsExprs, StartLoc, EndLoc);
3240     ClsExprs.clear();
3241     ClsExprs.push_back(Cls);
3242     Cls = SynthesizeCallToFunctionDecl(GetSuperClassFunctionDecl, ClsExprs,
3243                                        StartLoc, EndLoc);
3244
3245     // (id)class_getSuperclass((Class)objc_getClass("CurrentClass"))
3246     // To turn off a warning, type-cast to 'id'
3247     InitExprs.push_back( // set 'super class', using class_getSuperclass().
3248                         NoTypeInfoCStyleCastExpr(Context,
3249                                                  Context->getObjCIdType(),
3250                                                  CK_BitCast, Cls));
3251     // struct __rw_objc_super
3252     QualType superType = getSuperStructType();
3253     Expr *SuperRep;
3254
3255     if (LangOpts.MicrosoftExt) {
3256       SynthSuperConstructorFunctionDecl();
3257       // Simulate a constructor call...
3258       DeclRefExpr *DRE = new (Context)
3259           DeclRefExpr(*Context, SuperConstructorFunctionDecl, false, superType,
3260                       VK_LValue, SourceLocation());
3261       SuperRep =
3262           CallExpr::Create(*Context, DRE, InitExprs, superType, VK_LValue,
3263                            SourceLocation(), FPOptionsOverride());
3264       // The code for super is a little tricky to prevent collision with
3265       // the structure definition in the header. The rewriter has it's own
3266       // internal definition (__rw_objc_super) that is uses. This is why
3267       // we need the cast below. For example:
3268       // (struct __rw_objc_super *)&__rw_objc_super((id)self, (id)objc_getClass("SUPER"))
3269       //
3270       SuperRep = UnaryOperator::Create(
3271           const_cast<ASTContext &>(*Context), SuperRep, UO_AddrOf,
3272           Context->getPointerType(SuperRep->getType()), VK_RValue, OK_Ordinary,
3273           SourceLocation(), false, FPOptionsOverride());
3274       SuperRep = NoTypeInfoCStyleCastExpr(Context,
3275                                           Context->getPointerType(superType),
3276                                           CK_BitCast, SuperRep);
3277     } else {
3278       // (struct __rw_objc_super) { <exprs from above> }
3279       InitListExpr *ILE =
3280         new (Context) InitListExpr(*Context, SourceLocation(), InitExprs,
3281                                    SourceLocation());
3282       TypeSourceInfo *superTInfo
3283         = Context->getTrivialTypeSourceInfo(superType);
3284       SuperRep = new (Context) CompoundLiteralExpr(SourceLocation(), superTInfo,
3285                                                    superType, VK_LValue,
3286                                                    ILE, false);
3287       // struct __rw_objc_super *
3288       SuperRep = UnaryOperator::Create(
3289           const_cast<ASTContext &>(*Context), SuperRep, UO_AddrOf,
3290           Context->getPointerType(SuperRep->getType()), VK_RValue, OK_Ordinary,
3291           SourceLocation(), false, FPOptionsOverride());
3292     }
3293     MsgExprs.push_back(SuperRep);
3294     break;
3295   }
3296
3297   case ObjCMessageExpr::Class: {
3298     SmallVector<Expr*, 8> ClsExprs;
3299     ObjCInterfaceDecl *Class
3300       = Exp->getClassReceiver()->castAs<ObjCObjectType>()->getInterface();
3301     IdentifierInfo *clsName = Class->getIdentifier();
3302     ClsExprs.push_back(getStringLiteral(clsName->getName()));
3303     CallExpr *Cls = SynthesizeCallToFunctionDecl(GetClassFunctionDecl, ClsExprs,
3304                                                  StartLoc, EndLoc);
3305     CastExpr *ArgExpr = NoTypeInfoCStyleCastExpr(Context,
3306                                                  Context->getObjCIdType(),
3307                                                  CK_BitCast, Cls);
3308     MsgExprs.push_back(ArgExpr);
3309     break;
3310   }
3311
3312   case ObjCMessageExpr::SuperInstance:{
3313     MsgSendFlavor = MsgSendSuperFunctionDecl;
3314     if (MsgSendStretFlavor)
3315       MsgSendStretFlavor = MsgSendSuperStretFunctionDecl;
3316     assert(MsgSendFlavor && "MsgSendFlavor is NULL!");
3317     ObjCInterfaceDecl *ClassDecl = CurMethodDef->getClassInterface();
3318     SmallVector<Expr*, 4> InitExprs;
3319
3320     InitExprs.push_back(
3321       NoTypeInfoCStyleCastExpr(Context, Context->getObjCIdType(),
3322                                CK_BitCast,
3323                    new (Context) DeclRefExpr(*Context,
3324                                              CurMethodDef->getSelfDecl(),
3325                                              false,
3326                                              Context->getObjCIdType(),
3327                                              VK_RValue, SourceLocation()))
3328                         ); // set the 'receiver'.
3329
3330     // (id)class_getSuperclass((Class)objc_getClass("CurrentClass"))
3331     SmallVector<Expr*, 8> ClsExprs;
3332     ClsExprs.push_back(getStringLiteral(ClassDecl->getIdentifier()->getName()));
3333     // (Class)objc_getClass("CurrentClass")
3334     CallExpr *Cls = SynthesizeCallToFunctionDecl(GetClassFunctionDecl, ClsExprs,
3335                                                  StartLoc, EndLoc);
3336     ClsExprs.clear();
3337     ClsExprs.push_back(Cls);
3338     Cls = SynthesizeCallToFunctionDecl(GetSuperClassFunctionDecl, ClsExprs,
3339                                        StartLoc, EndLoc);
3340
3341     // (id)class_getSuperclass((Class)objc_getClass("CurrentClass"))
3342     // To turn off a warning, type-cast to 'id'
3343     InitExprs.push_back(
3344       // set 'super class', using class_getSuperclass().
3345       NoTypeInfoCStyleCastExpr(Context, Context->getObjCIdType(),
3346                                CK_BitCast, Cls));
3347     // struct __rw_objc_super
3348     QualType superType = getSuperStructType();
3349     Expr *SuperRep;
3350
3351     if (LangOpts.MicrosoftExt) {
3352       SynthSuperConstructorFunctionDecl();
3353       // Simulate a constructor call...
3354       DeclRefExpr *DRE = new (Context)
3355           DeclRefExpr(*Context, SuperConstructorFunctionDecl, false, superType,
3356                       VK_LValue, SourceLocation());
3357       SuperRep =
3358           CallExpr::Create(*Context, DRE, InitExprs, superType, VK_LValue,
3359                            SourceLocation(), FPOptionsOverride());
3360       // The code for super is a little tricky to prevent collision with
3361       // the structure definition in the header. The rewriter has it's own
3362       // internal definition (__rw_objc_super) that is uses. This is why
3363       // we need the cast below. For example:
3364       // (struct __rw_objc_super *)&__rw_objc_super((id)self, (id)objc_getClass("SUPER"))
3365       //
3366       SuperRep = UnaryOperator::Create(
3367           const_cast<ASTContext &>(*Context), SuperRep, UO_AddrOf,
3368           Context->getPointerType(SuperRep->getType()), VK_RValue, OK_Ordinary,
3369           SourceLocation(), false, FPOptionsOverride());
3370       SuperRep = NoTypeInfoCStyleCastExpr(Context,
3371                                Context->getPointerType(superType),
3372                                CK_BitCast, SuperRep);
3373     } else {
3374       // (struct __rw_objc_super) { <exprs from above> }
3375       InitListExpr *ILE =
3376         new (Context) InitListExpr(*Context, SourceLocation(), InitExprs,
3377                                    SourceLocation());
3378       TypeSourceInfo *superTInfo
3379         = Context->getTrivialTypeSourceInfo(superType);
3380       SuperRep = new (Context) CompoundLiteralExpr(SourceLocation(), superTInfo,
3381                                                    superType, VK_RValue, ILE,
3382                                                    false);
3383     }
3384     MsgExprs.push_back(SuperRep);
3385     break;
3386   }
3387
3388   case ObjCMessageExpr::Instance: {
3389     // Remove all type-casts because it may contain objc-style types; e.g.
3390     // Foo<Proto> *.
3391     Expr *recExpr = Exp->getInstanceReceiver();
3392     while (CStyleCastExpr *CE = dyn_cast<CStyleCastExpr>(recExpr))
3393       recExpr = CE->getSubExpr();
3394     CastKind CK = recExpr->getType()->isObjCObjectPointerType()
3395                     ? CK_BitCast : recExpr->getType()->isBlockPointerType()
3396                                      ? CK_BlockPointerToObjCPointerCast
3397                                      : CK_CPointerToObjCPointerCast;
3398
3399     recExpr = NoTypeInfoCStyleCastExpr(Context, Context->getObjCIdType(),
3400                                        CK, recExpr);
3401     MsgExprs.push_back(recExpr);
3402     break;
3403   }
3404   }
3405
3406   // Create a call to sel_registerName("selName"), it will be the 2nd argument.
3407   SmallVector<Expr*, 8> SelExprs;
3408   SelExprs.push_back(getStringLiteral(Exp->getSelector().getAsString()));
3409   CallExpr *SelExp = SynthesizeCallToFunctionDecl(SelGetUidFunctionDecl,
3410                                                   SelExprs, StartLoc, EndLoc);
3411   MsgExprs.push_back(SelExp);
3412
3413   // Now push any user supplied arguments.
3414   for (unsigned i = 0; i < Exp->getNumArgs(); i++) {
3415     Expr *userExpr = Exp->getArg(i);
3416     // Make all implicit casts explicit...ICE comes in handy:-)
3417     if (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(userExpr)) {
3418       // Reuse the ICE type, it is exactly what the doctor ordered.
3419       QualType type = ICE->getType();
3420       if (needToScanForQualifiers(type))
3421         type = Context->getObjCIdType();
3422       // Make sure we convert "type (^)(...)" to "type (*)(...)".
3423       (void)convertBlockPointerToFunctionPointer(type);
3424       const Expr *SubExpr = ICE->IgnoreParenImpCasts();
3425       CastKind CK;
3426       if (SubExpr->getType()->isIntegralType(*Context) &&
3427           type->isBooleanType()) {
3428         CK = CK_IntegralToBoolean;
3429       } else if (type->isObjCObjectPointerType()) {
3430         if (SubExpr->getType()->isBlockPointerType()) {
3431           CK = CK_BlockPointerToObjCPointerCast;
3432         } else if (SubExpr->getType()->isPointerType()) {
3433           CK = CK_CPointerToObjCPointerCast;
3434         } else {
3435           CK = CK_BitCast;
3436         }
3437       } else {
3438         CK = CK_BitCast;
3439       }
3440
3441       userExpr = NoTypeInfoCStyleCastExpr(Context, type, CK, userExpr);
3442     }
3443     // Make id<P...> cast into an 'id' cast.
3444     else if (CStyleCastExpr *CE = dyn_cast<CStyleCastExpr>(userExpr)) {
3445       if (CE->getType()->isObjCQualifiedIdType()) {
3446         while ((CE = dyn_cast<CStyleCastExpr>(userExpr)))
3447           userExpr = CE->getSubExpr();
3448         CastKind CK;
3449         if (userExpr->getType()->isIntegralType(*Context)) {
3450           CK = CK_IntegralToPointer;
3451         } else if (userExpr->getType()->isBlockPointerType()) {
3452           CK = CK_BlockPointerToObjCPointerCast;
3453         } else if (userExpr->getType()->isPointerType()) {
3454           CK = CK_CPointerToObjCPointerCast;
3455         } else {
3456           CK = CK_BitCast;
3457         }
3458         userExpr = NoTypeInfoCStyleCastExpr(Context, Context->getObjCIdType(),
3459                                             CK, userExpr);
3460       }
3461     }
3462     MsgExprs.push_back(userExpr);
3463     // We've transferred the ownership to MsgExprs. For now, we *don't* null
3464     // out the argument in the original expression (since we aren't deleting
3465     // the ObjCMessageExpr). See RewritePropertyOrImplicitSetter() usage for more info.
3466     //Exp->setArg(i, 0);
3467   }
3468   // Generate the funky cast.
3469   CastExpr *cast;
3470   SmallVector<QualType, 8> ArgTypes;
3471   QualType returnType;
3472
3473   // Push 'id' and 'SEL', the 2 implicit arguments.
3474   if (MsgSendFlavor == MsgSendSuperFunctionDecl)
3475     ArgTypes.push_back(Context->getPointerType(getSuperStructType()));
3476   else
3477     ArgTypes.push_back(Context->getObjCIdType());
3478   ArgTypes.push_back(Context->getObjCSelType());
3479   if (ObjCMethodDecl *OMD = Exp->getMethodDecl()) {
3480     // Push any user argument types.
3481     for (const auto *PI : OMD->parameters()) {
3482       QualType t = PI->getType()->isObjCQualifiedIdType()
3483                      ? Context->getObjCIdType()
3484                      : PI->getType();
3485       // Make sure we convert "t (^)(...)" to "t (*)(...)".
3486       (void)convertBlockPointerToFunctionPointer(t);
3487       ArgTypes.push_back(t);
3488     }
3489     returnType = Exp->getType();
3490     convertToUnqualifiedObjCType(returnType);
3491     (void)convertBlockPointerToFunctionPointer(returnType);
3492   } else {
3493     returnType = Context->getObjCIdType();
3494   }
3495   // Get the type, we will need to reference it in a couple spots.
3496   QualType msgSendType = MsgSendFlavor->getType();
3497
3498   // Create a reference to the objc_msgSend() declaration.
3499   DeclRefExpr *DRE = new (Context) DeclRefExpr(
3500       *Context, MsgSendFlavor, false, msgSendType, VK_LValue, SourceLocation());
3501
3502   // Need to cast objc_msgSend to "void *" (to workaround a GCC bandaid).
3503   // If we don't do this cast, we get the following bizarre warning/note:
3504   // xx.m:13: warning: function called through a non-compatible type
3505   // xx.m:13: note: if this code is reached, the program will abort
3506   cast = NoTypeInfoCStyleCastExpr(Context,
3507                                   Context->getPointerType(Context->VoidTy),
3508                                   CK_BitCast, DRE);
3509
3510   // Now do the "normal" pointer to function cast.
3511   // If we don't have a method decl, force a variadic cast.
3512   const ObjCMethodDecl *MD = Exp->getMethodDecl();
3513   QualType castType =
3514     getSimpleFunctionType(returnType, ArgTypes, MD ? MD->isVariadic() : true);
3515   castType = Context->getPointerType(castType);
3516   cast = NoTypeInfoCStyleCastExpr(Context, castType, CK_BitCast,
3517                                   cast);
3518
3519   // Don't forget the parens to enforce the proper binding.
3520   ParenExpr *PE = new (Context) ParenExpr(StartLoc, EndLoc, cast);
3521
3522   const FunctionType *FT = msgSendType->castAs<FunctionType>();
3523   CallExpr *CE = CallExpr::Create(*Context, PE, MsgExprs, FT->getReturnType(),
3524                                   VK_RValue, EndLoc, FPOptionsOverride());
3525   Stmt *ReplacingStmt = CE;
3526   if (MsgSendStretFlavor) {
3527     // We have the method which returns a struct/union. Must also generate
3528     // call to objc_msgSend_stret and hang both varieties on a conditional
3529     // expression which dictate which one to envoke depending on size of
3530     // method's return type.
3531
3532     Expr *STCE = SynthMsgSendStretCallExpr(MsgSendStretFlavor,
3533                                            returnType,
3534                                            ArgTypes, MsgExprs,
3535                                            Exp->getMethodDecl());
3536     ReplacingStmt = STCE;
3537   }
3538   // delete Exp; leak for now, see RewritePropertyOrImplicitSetter() usage for more info.
3539   return ReplacingStmt;
3540 }
3541
3542 Stmt *RewriteModernObjC::RewriteMessageExpr(ObjCMessageExpr *Exp) {
3543   Stmt *ReplacingStmt =
3544       SynthMessageExpr(Exp, Exp->getBeginLoc(), Exp->getEndLoc());
3545
3546   // Now do the actual rewrite.
3547   ReplaceStmt(Exp, ReplacingStmt);
3548
3549   // delete Exp; leak for now, see RewritePropertyOrImplicitSetter() usage for more info.
3550   return ReplacingStmt;
3551 }
3552
3553 // typedef struct objc_object Protocol;
3554 QualType RewriteModernObjC::getProtocolType() {
3555   if (!ProtocolTypeDecl) {
3556     TypeSourceInfo *TInfo
3557       = Context->getTrivialTypeSourceInfo(Context->getObjCIdType());
3558     ProtocolTypeDecl = TypedefDecl::Create(*Context, TUDecl,
3559                                            SourceLocation(), SourceLocation(),
3560                                            &Context->Idents.get("Protocol"),
3561                                            TInfo);
3562   }
3563   return Context->getTypeDeclType(ProtocolTypeDecl);
3564 }
3565
3566 /// RewriteObjCProtocolExpr - Rewrite a protocol expression into
3567 /// a synthesized/forward data reference (to the protocol's metadata).
3568 /// The forward references (and metadata) are generated in
3569 /// RewriteModernObjC::HandleTranslationUnit().
3570 Stmt *RewriteModernObjC::RewriteObjCProtocolExpr(ObjCProtocolExpr *Exp) {
3571   std::string Name = "_OBJC_PROTOCOL_REFERENCE_$_" +
3572                       Exp->getProtocol()->getNameAsString();
3573   IdentifierInfo *ID = &Context->Idents.get(Name);
3574   VarDecl *VD =
3575       VarDecl::Create(*Context, TUDecl, SourceLocation(), SourceLocation(), ID,
3576                       getProtocolType(), nullptr, StorageClass::Extern);
3577   DeclRefExpr *DRE = new (Context) DeclRefExpr(
3578       *Context, VD, false, getProtocolType(), VK_LValue, SourceLocation());
3579   CastExpr *castExpr = NoTypeInfoCStyleCastExpr(
3580       Context, Context->getPointerType(DRE->getType()), CK_BitCast, DRE);
3581   ReplaceStmt(Exp, castExpr);
3582   ProtocolExprDecls.insert(Exp->getProtocol()->getCanonicalDecl());
3583   // delete Exp; leak for now, see RewritePropertyOrImplicitSetter() usage for more info.
3584   return castExpr;
3585 }
3586
3587 /// IsTagDefinedInsideClass - This routine checks that a named tagged type
3588 /// is defined inside an objective-c class. If so, it returns true.
3589 bool RewriteModernObjC::IsTagDefinedInsideClass(ObjCContainerDecl *IDecl,
3590                                                 TagDecl *Tag,
3591                                                 bool &IsNamedDefinition) {
3592   if (!IDecl)
3593     return false;
3594   SourceLocation TagLocation;
3595   if (RecordDecl *RD = dyn_cast<RecordDecl>(Tag)) {
3596     RD = RD->getDefinition();
3597     if (!RD || !RD->getDeclName().getAsIdentifierInfo())
3598       return false;
3599     IsNamedDefinition = true;
3600     TagLocation = RD->getLocation();
3601     return Context->getSourceManager().isBeforeInTranslationUnit(
3602                                           IDecl->getLocation(), TagLocation);
3603   }
3604   if (EnumDecl *ED = dyn_cast<EnumDecl>(Tag)) {
3605     if (!ED || !ED->getDeclName().getAsIdentifierInfo())
3606       return false;
3607     IsNamedDefinition = true;
3608     TagLocation = ED->getLocation();
3609     return Context->getSourceManager().isBeforeInTranslationUnit(
3610                                           IDecl->getLocation(), TagLocation);
3611   }
3612   return false;
3613 }
3614
3615 /// RewriteObjCFieldDeclType - This routine rewrites a type into the buffer.
3616 /// It handles elaborated types, as well as enum types in the process.
3617 bool RewriteModernObjC::RewriteObjCFieldDeclType(QualType &Type,
3618                                                  std::string &Result) {
3619   if (isa<TypedefType>(Type)) {
3620     Result += "\t";
3621     return false;
3622   }
3623
3624   if (Type->isArrayType()) {
3625     QualType ElemTy = Context->getBaseElementType(Type);
3626     return RewriteObjCFieldDeclType(ElemTy, Result);
3627   }
3628   else if (Type->isRecordType()) {
3629     RecordDecl *RD = Type->castAs<RecordType>()->getDecl();
3630     if (RD->isCompleteDefinition()) {
3631       if (RD->isStruct())
3632         Result += "\n\tstruct ";
3633       else if (RD->isUnion())
3634         Result += "\n\tunion ";
3635       else
3636         assert(false && "class not allowed as an ivar type");
3637
3638       Result += RD->getName();
3639       if (GlobalDefinedTags.count(RD)) {
3640         // struct/union is defined globally, use it.
3641         Result += " ";
3642         return true;
3643       }
3644       Result += " {\n";
3645       for (auto *FD : RD->fields())
3646         RewriteObjCFieldDecl(FD, Result);
3647       Result += "\t} ";
3648       return true;
3649     }
3650   }
3651   else if (Type->isEnumeralType()) {
3652     EnumDecl *ED = Type->castAs<EnumType>()->getDecl();
3653     if (ED->isCompleteDefinition()) {
3654       Result += "\n\tenum ";
3655       Result += ED->getName();
3656       if (GlobalDefinedTags.count(ED)) {
3657         // Enum is globall defined, use it.
3658         Result += " ";
3659         return true;
3660       }
3661
3662       Result += " {\n";
3663       for (const auto *EC : ED->enumerators()) {
3664         Result += "\t"; Result += EC->getName(); Result += " = ";
3665         llvm::APSInt Val = EC->getInitVal();
3666         Result += Val.toString(10);
3667         Result += ",\n";
3668       }
3669       Result += "\t} ";
3670       return true;
3671     }
3672   }
3673
3674   Result += "\t";
3675   convertObjCTypeToCStyleType(Type);
3676   return false;
3677 }
3678
3679
3680 /// RewriteObjCFieldDecl - This routine rewrites a field into the buffer.
3681 /// It handles elaborated types, as well as enum types in the process.
3682 void RewriteModernObjC::RewriteObjCFieldDecl(FieldDecl *fieldDecl,
3683                                              std::string &Result) {
3684   QualType Type = fieldDecl->getType();
3685   std::string Name = fieldDecl->getNameAsString();
3686
3687   bool EleboratedType = RewriteObjCFieldDeclType(Type, Result);
3688   if (!EleboratedType)
3689     Type.getAsStringInternal(Name, Context->getPrintingPolicy());
3690   Result += Name;
3691   if (fieldDecl->isBitField()) {
3692     Result += " : "; Result += utostr(fieldDecl->getBitWidthValue(*Context));
3693   }
3694   else if (EleboratedType && Type->isArrayType()) {
3695     const ArrayType *AT = Context->getAsArrayType(Type);
3696     do {
3697       if (const ConstantArrayType *CAT = dyn_cast<ConstantArrayType>(AT)) {
3698         Result += "[";
3699         llvm::APInt Dim = CAT->getSize();
3700         Result += utostr(Dim.getZExtValue());
3701         Result += "]";
3702       }
3703       AT = Context->getAsArrayType(AT->getElementType());
3704     } while (AT);
3705   }
3706
3707   Result += ";\n";
3708 }
3709
3710 /// RewriteLocallyDefinedNamedAggregates - This routine rewrites locally defined
3711 /// named aggregate types into the input buffer.
3712 void RewriteModernObjC::RewriteLocallyDefinedNamedAggregates(FieldDecl *fieldDecl,
3713                                              std::string &Result) {
3714   QualType Type = fieldDecl->getType();
3715   if (isa<TypedefType>(Type))
3716     return;
3717   if (Type->isArrayType())
3718     Type = Context->getBaseElementType(Type);
3719
3720   auto *IDecl = dyn_cast<ObjCContainerDecl>(fieldDecl->getDeclContext());
3721
3722   TagDecl *TD = nullptr;
3723   if (Type->isRecordType()) {
3724     TD = Type->castAs<RecordType>()->getDecl();
3725   }
3726   else if (Type->isEnumeralType()) {
3727     TD = Type->castAs<EnumType>()->getDecl();
3728   }
3729
3730   if (TD) {
3731     if (GlobalDefinedTags.count(TD))
3732       return;
3733
3734     bool IsNamedDefinition = false;
3735     if (IsTagDefinedInsideClass(IDecl, TD, IsNamedDefinition)) {
3736       RewriteObjCFieldDeclType(Type, Result);
3737       Result += ";";
3738     }
3739     if (IsNamedDefinition)
3740       GlobalDefinedTags.insert(TD);
3741   }
3742 }
3743
3744 unsigned RewriteModernObjC::ObjCIvarBitfieldGroupNo(ObjCIvarDecl *IV) {
3745   const ObjCInterfaceDecl *CDecl = IV->getContainingInterface();
3746   if (ObjCInterefaceHasBitfieldGroups.count(CDecl)) {
3747     return IvarGroupNumber[IV];
3748   }
3749   unsigned GroupNo = 0;
3750   SmallVector<const ObjCIvarDecl *, 8> IVars;
3751   for (const ObjCIvarDecl *IVD = CDecl->all_declared_ivar_begin();
3752        IVD; IVD = IVD->getNextIvar())
3753     IVars.push_back(IVD);
3754
3755   for (unsigned i = 0, e = IVars.size(); i < e; i++)
3756     if (IVars[i]->isBitField()) {
3757       IvarGroupNumber[IVars[i++]] = ++GroupNo;
3758       while (i < e && IVars[i]->isBitField())
3759         IvarGroupNumber[IVars[i++]] = GroupNo;
3760       if (i < e)
3761         --i;
3762     }
3763
3764   ObjCInterefaceHasBitfieldGroups.insert(CDecl);
3765   return IvarGroupNumber[IV];
3766 }
3767
3768 QualType RewriteModernObjC::SynthesizeBitfieldGroupStructType(
3769                               ObjCIvarDecl *IV,
3770                               SmallVectorImpl<ObjCIvarDecl *> &IVars) {
3771   std::string StructTagName;
3772   ObjCIvarBitfieldGroupType(IV, StructTagName);
3773   RecordDecl *RD = RecordDecl::Create(*Context, TTK_Struct,
3774                                       Context->getTranslationUnitDecl(),
3775                                       SourceLocation(), SourceLocation(),
3776                                       &Context->Idents.get(StructTagName));
3777   for (unsigned i=0, e = IVars.size(); i < e; i++) {
3778     ObjCIvarDecl *Ivar = IVars[i];
3779     RD->addDecl(FieldDecl::Create(*Context, RD, SourceLocation(), SourceLocation(),
3780                                   &Context->Idents.get(Ivar->getName()),
3781                                   Ivar->getType(),
3782                                   nullptr, /*Expr *BW */Ivar->getBitWidth(),
3783                                   false, ICIS_NoInit));
3784   }
3785   RD->completeDefinition();
3786   return Context->getTagDeclType(RD);
3787 }
3788
3789 QualType RewriteModernObjC::GetGroupRecordTypeForObjCIvarBitfield(ObjCIvarDecl *IV) {
3790   const ObjCInterfaceDecl *CDecl = IV->getContainingInterface();
3791   unsigned GroupNo = ObjCIvarBitfieldGroupNo(IV);
3792   std::pair<const ObjCInterfaceDecl*, unsigned> tuple = std::make_pair(CDecl, GroupNo);
3793   if (GroupRecordType.count(tuple))
3794     return GroupRecordType[tuple];
3795
3796   SmallVector<ObjCIvarDecl *, 8> IVars;
3797   for (const ObjCIvarDecl *IVD = CDecl->all_declared_ivar_begin();
3798        IVD; IVD = IVD->getNextIvar()) {
3799     if (IVD->isBitField())
3800       IVars.push_back(const_cast<ObjCIvarDecl *>(IVD));
3801     else {
3802       if (!IVars.empty()) {
3803         unsigned GroupNo = ObjCIvarBitfieldGroupNo(IVars[0]);
3804         // Generate the struct type for this group of bitfield ivars.
3805         GroupRecordType[std::make_pair(CDecl, GroupNo)] =
3806           SynthesizeBitfieldGroupStructType(IVars[0], IVars);
3807         IVars.clear();
3808       }
3809     }
3810   }
3811   if (!IVars.empty()) {
3812     // Do the last one.
3813     unsigned GroupNo = ObjCIvarBitfieldGroupNo(IVars[0]);
3814     GroupRecordType[std::make_pair(CDecl, GroupNo)] =
3815       SynthesizeBitfieldGroupStructType(IVars[0], IVars);
3816   }
3817   QualType RetQT = GroupRecordType[tuple];
3818   assert(!RetQT.isNull() && "GetGroupRecordTypeForObjCIvarBitfield struct type is NULL");
3819
3820   return RetQT;
3821 }
3822
3823 ///&