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