//===-- RewriteModernObjC.cpp - Playground for the code rewriter ----------===//

//

// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.

// See https://llvm.org/LICENSE.txt for license information.

// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception

//

//===----------------------------------------------------------------------===//

//

// Hacks and fun related to the code rewriter.

//

//===----------------------------------------------------------------------===//

#include "clang/Rewrite/Frontend/ASTConsumers.h"

#include "clang/AST/AST.h"

#include "clang/AST/ASTConsumer.h"

#include "clang/AST/Attr.h"

#include "clang/AST/ParentMap.h"

#include "clang/Basic/CharInfo.h"

#include "clang/Basic/Diagnostic.h"

#include "clang/Basic/IdentifierTable.h"

#include "clang/Basic/SourceManager.h"

#include "clang/Basic/TargetInfo.h"

#include "clang/Config/config.h"

#include "clang/Lex/Lexer.h"

#include "clang/Rewrite/Core/Rewriter.h"

#include "llvm/ADT/DenseSet.h"

#include "llvm/ADT/SetVector.h"

#include "llvm/ADT/SmallPtrSet.h"

#include "llvm/ADT/StringExtras.h"

#include "llvm/Support/MemoryBuffer.h"

#include "llvm/Support/raw_ostream.h"

#include <memory>

#if CLANG_ENABLE_OBJC_REWRITER

using namespace clang;

using llvm::utostr;

namespace {

  class RewriteModernObjC : public ASTConsumer {

  protected:

    enum {

      BLOCK_FIELD_IS_OBJECT   =  3,  /* id, NSObject, __attribute__((NSObject)),

                                        block, ... */

      BLOCK_FIELD_IS_BLOCK    =  7,  /* a block variable */

      BLOCK_FIELD_IS_BYREF    =  8,  /* the on stack structure holding the

                                        __block variable */

      BLOCK_FIELD_IS_WEAK     = 16,  /* declared __weak, only used in byref copy

                                        helpers */

      BLOCK_BYREF_CALLER      = 128, /* called from __block (byref) copy/dispose

                                        support routines */

      BLOCK_BYREF_CURRENT_MAX = 256

    };

    enum {

      BLOCK_NEEDS_FREE =        (1 << 24),

      BLOCK_HAS_COPY_DISPOSE =  (1 << 25),

      BLOCK_HAS_CXX_OBJ =       (1 << 26),

      BLOCK_IS_GC =             (1 << 27),

      BLOCK_IS_GLOBAL =         (1 << 28),

      BLOCK_HAS_DESCRIPTOR =    (1 << 29)

    };

    Rewriter Rewrite;

    DiagnosticsEngine &Diags;

    const LangOptions &LangOpts;

    ASTContext *Context;

    SourceManager *SM;

    TranslationUnitDecl *TUDecl;

    FileID MainFileID;

    const char *MainFileStart, *MainFileEnd;

    Stmt *CurrentBody;

    ParentMap *PropParentMap; // created lazily.

    std::string InFileName;

    std::unique_ptr<raw_ostream> OutFile;

    std::string Preamble;

    TypeDecl *ProtocolTypeDecl;

    VarDecl *GlobalVarDecl;

    Expr *GlobalConstructionExp;

    unsigned RewriteFailedDiag;

    unsigned GlobalBlockRewriteFailedDiag;

    // ObjC string constant support.

    unsigned NumObjCStringLiterals;

    VarDecl *ConstantStringClassReference;

    RecordDecl *NSStringRecord;

    // ObjC foreach break/continue generation support.

    int BcLabelCount;

    unsigned TryFinallyContainsReturnDiag;

    // Needed for super.

    ObjCMethodDecl *CurMethodDef;

    RecordDecl *SuperStructDecl;

    RecordDecl *ConstantStringDecl;

    FunctionDecl *MsgSendFunctionDecl;

    FunctionDecl *MsgSendSuperFunctionDecl;

    FunctionDecl *MsgSendStretFunctionDecl;

    FunctionDecl *MsgSendSuperStretFunctionDecl;

    FunctionDecl *MsgSendFpretFunctionDecl;

    FunctionDecl *GetClassFunctionDecl;

    FunctionDecl *GetMetaClassFunctionDecl;

    FunctionDecl *GetSuperClassFunctionDecl;

    FunctionDecl *SelGetUidFunctionDecl;

    FunctionDecl *CFStringFunctionDecl;

    FunctionDecl *SuperConstructorFunctionDecl;

    FunctionDecl *CurFunctionDef;

    /* Misc. containers needed for meta-data rewrite. */

    SmallVector<ObjCImplementationDecl *, 8> ClassImplementation;

    SmallVector<ObjCCategoryImplDecl *, 8> CategoryImplementation;

    llvm::SmallPtrSet<ObjCInterfaceDecl*, 8> ObjCSynthesizedStructs;

    llvm::SmallPtrSet<ObjCProtocolDecl*, 8> ObjCSynthesizedProtocols;

    llvm::SmallPtrSet<ObjCInterfaceDecl*, 8> ObjCWrittenInterfaces;

    llvm::SmallPtrSet<TagDecl*, 32> GlobalDefinedTags;

    SmallVector<ObjCInterfaceDecl*, 32> ObjCInterfacesSeen;

    /// DefinedNonLazyClasses - List of defined "non-lazy" classes.

    SmallVector<ObjCInterfaceDecl*, 8> DefinedNonLazyClasses;

    /// DefinedNonLazyCategories - List of defined "non-lazy" categories.

    SmallVector<ObjCCategoryDecl *, 8> DefinedNonLazyCategories;

    SmallVector<Stmt *, 32> Stmts;

    SmallVector<int, 8> ObjCBcLabelNo;

    // Remember all the @protocol(<expr>) expressions.

    llvm::SmallPtrSet<ObjCProtocolDecl *, 32> ProtocolExprDecls;

    llvm::DenseSet<uint64_t> CopyDestroyCache;

    // Block expressions.

    SmallVector<BlockExpr *, 32> Blocks;

    SmallVector<int, 32> InnerDeclRefsCount;

    SmallVector<DeclRefExpr *, 32> InnerDeclRefs;

    SmallVector<DeclRefExpr *, 32> BlockDeclRefs;

    // Block related declarations.

    SmallVector<ValueDecl *, 8> BlockByCopyDecls;

    llvm::SmallPtrSet<ValueDecl *, 8> BlockByCopyDeclsPtrSet;

    SmallVector<ValueDecl *, 8> BlockByRefDecls;

    llvm::SmallPtrSet<ValueDecl *, 8> BlockByRefDeclsPtrSet;

    llvm::DenseMap<ValueDecl *, unsigned> BlockByRefDeclNo;

    llvm::SmallPtrSet<ValueDecl *, 8> ImportedBlockDecls;

    llvm::SmallPtrSet<VarDecl *, 8> ImportedLocalExternalDecls;

    llvm::DenseMap<BlockExpr *, std::string> RewrittenBlockExprs;

    llvm::DenseMap<ObjCInterfaceDecl *,

                    llvm::SmallSetVector<ObjCIvarDecl *, 8> > ReferencedIvars;

    // ivar bitfield grouping containers

    llvm::DenseSet<const ObjCInterfaceDecl *> ObjCInterefaceHasBitfieldGroups;

    llvm::DenseMap<const ObjCIvarDecl* , unsigned> IvarGroupNumber;

    // This container maps an <class, group number for ivar> tuple to the type

    // of the struct where the bitfield belongs.

    llvm::DenseMap<std::pair<const ObjCInterfaceDecl*, unsigned>, QualType> GroupRecordType;

    SmallVector<FunctionDecl*, 32> FunctionDefinitionsSeen;

    // This maps an original source AST to it's rewritten form. This allows

    // us to avoid rewriting the same node twice (which is very uncommon).

    // This is needed to support some of the exotic property rewriting.

    llvm::DenseMap<Stmt *, Stmt *> ReplacedNodes;

    // Needed for header files being rewritten

    bool IsHeader;

    bool SilenceRewriteMacroWarning;

    bool GenerateLineInfo;

    bool objc_impl_method;

    bool DisableReplaceStmt;

    class DisableReplaceStmtScope {

      RewriteModernObjC &R;

      bool SavedValue;

    public:

      DisableReplaceStmtScope(RewriteModernObjC &R)

        : R(R), SavedValue(R.DisableReplaceStmt) {

        R.DisableReplaceStmt = true;

      }

      ~DisableReplaceStmtScope() {

        R.DisableReplaceStmt = SavedValue;

      }

    };

    void InitializeCommon(ASTContext &context);

  public:

    llvm::DenseMap<ObjCMethodDecl*, std::string> MethodInternalNames;

    // Top Level Driver code.

    bool HandleTopLevelDecl(DeclGroupRef D) override {

      for (DeclGroupRef::iterator I = D.begin(), E = D.end(); I != E; 
++I414
) {

        if (ObjCInterfaceDecl *Class = dyn_cast<ObjCInterfaceDecl>(*I)) {

          if (!Class->isThisDeclarationADefinition()) {

            RewriteForwardClassDecl(D);

            break;

          } else {

            // Keep track of all interface declarations seen.

            ObjCInterfacesSeen.push_back(Class);

            break;

          }

        }

        if (ObjCProtocolDecl *Proto = dyn_cast<ObjCProtocolDecl>(*I)) {

          if (!Proto->isThisDeclarationADefinition()) {

            RewriteForwardProtocolDecl(D);

            break;

          }

        }

        if (FunctionDecl *FDecl = dyn_cast<FunctionDecl>(*I)) {

          // Under modern abi, we cannot translate body of the function

          // yet until all class extensions and its implementation is seen.

          // This is because they may introduce new bitfields which must go

          // into their grouping struct.

          if (FDecl->isThisDeclarationADefinition() &&

              // Not c functions defined inside an objc container.

              
!FDecl->isTopLevelDeclInObjCContainer()96
) {

            FunctionDefinitionsSeen.push_back(FDecl);

            break;

          }

        }

        HandleTopLevelSingleDecl(*I);

      }

      return true;

    }

    void HandleTopLevelDeclInObjCContainer(DeclGroupRef D) override {

      for (DeclGroupRef::iterator I = D.begin(), E = D.end(); I != E; 
++I1
) {

        if (TypedefNameDecl *TD = dyn_cast<TypedefNameDecl>(*I)) {

          if (isTopLevelBlockPointerType(TD->getUnderlyingType()))

            RewriteBlockPointerDecl(TD);

          else if (TD->getUnderlyingType()->isFunctionPointerType())

            CheckFunctionPointerDecl(TD->getUnderlyingType(), TD);

          else

            RewriteObjCQualifiedInterfaceTypes(TD);

        }

      }

    }

    void HandleTopLevelSingleDecl(Decl *D);

    void HandleDeclInMainFile(Decl *D);

    RewriteModernObjC(std::string inFile, std::unique_ptr<raw_ostream> OS,

                      DiagnosticsEngine &D, const LangOptions &LOpts,

                      bool silenceMacroWarn, bool LineInfo);

    ~RewriteModernObjC() override {}

    void HandleTranslationUnit(ASTContext &C) override;

    void ReplaceStmt(Stmt *Old, Stmt *New) {

      ReplaceStmtWithRange(Old, New, Old->getSourceRange());

    }

    void ReplaceStmtWithRange(Stmt *Old, Stmt *New, SourceRange SrcRange) {

      assert(Old != nullptr && New != nullptr && "Expected non-null Stmt's");

      Stmt *ReplacingStmt = ReplacedNodes[Old];

      if (ReplacingStmt)

        return; // We can't rewrite the same node twice.

      if (DisableReplaceStmt)

        return;

      // Measure the old text.

      int Size = Rewrite.getRangeSize(SrcRange);

      if (Size == -1) {

        Diags.Report(Context->getFullLoc(Old->getBeginLoc()), RewriteFailedDiag)

            << Old->getSourceRange();

        return;

      }

      // Get the new text.

      std::string SStr;

      llvm::raw_string_ostream S(SStr);

      New->printPretty(S, nullptr, PrintingPolicy(LangOpts));

      const std::string &Str = S.str();

      // If replacement succeeded or warning disabled return with no warning.

      if (!Rewrite.ReplaceText(SrcRange.getBegin(), Size, Str)) {

        ReplacedNodes[Old] = New;

        return;

      }

      if (SilenceRewriteMacroWarning)

        return;

      Diags.Report(Context->getFullLoc(Old->getBeginLoc()), RewriteFailedDiag)

          << Old->getSourceRange();

    }

    void InsertText(SourceLocation Loc, StringRef Str,

                    bool InsertAfter = true) {

      // If insertion succeeded or warning disabled return with no warning.

      if (!Rewrite.InsertText(Loc, Str, InsertAfter) ||

          
SilenceRewriteMacroWarning0
)

        return;

      Diags.Report(Context->getFullLoc(Loc), RewriteFailedDiag);

    }

    void ReplaceText(SourceLocation Start, unsigned OrigLength,

                     StringRef Str) {

      // If removal succeeded or warning disabled return with no warning.

      if (!Rewrite.ReplaceText(Start, OrigLength, Str) ||

          
SilenceRewriteMacroWarning0
)

        return;

      Diags.Report(Context->getFullLoc(Start), RewriteFailedDiag);

    }

    // Syntactic Rewriting.

    void RewriteRecordBody(RecordDecl *RD);

    void RewriteInclude();

    void RewriteLineDirective(const Decl *D);

    void ConvertSourceLocationToLineDirective(SourceLocation Loc,

                                              std::string &LineString);

    void RewriteForwardClassDecl(DeclGroupRef D);

    void RewriteForwardClassDecl(const SmallVectorImpl<Decl *> &DG);

    void RewriteForwardClassEpilogue(ObjCInterfaceDecl *ClassDecl,

                                     const std::string &typedefString);

    void RewriteImplementations();

    void RewritePropertyImplDecl(ObjCPropertyImplDecl *PID,

                                 ObjCImplementationDecl *IMD,

                                 ObjCCategoryImplDecl *CID);

    void RewriteInterfaceDecl(ObjCInterfaceDecl *Dcl);

    void RewriteImplementationDecl(Decl *Dcl);

    void RewriteObjCMethodDecl(const ObjCInterfaceDecl *IDecl,

                               ObjCMethodDecl *MDecl, std::string &ResultStr);

    void RewriteTypeIntoString(QualType T, std::string &ResultStr,

                               const FunctionType *&FPRetType);

    void RewriteByRefString(std::string &ResultStr, const std::string &Name,

                            ValueDecl *VD, bool def=false);

    void RewriteCategoryDecl(ObjCCategoryDecl *Dcl);

    void RewriteProtocolDecl(ObjCProtocolDecl *Dcl);

    void RewriteForwardProtocolDecl(DeclGroupRef D);

    void RewriteForwardProtocolDecl(const SmallVectorImpl<Decl *> &DG);

    void RewriteMethodDeclaration(ObjCMethodDecl *Method);

    void RewriteProperty(ObjCPropertyDecl *prop);

    void RewriteFunctionDecl(FunctionDecl *FD);

    void RewriteBlockPointerType(std::string& Str, QualType Type);

    void RewriteBlockPointerTypeVariable(std::string& Str, ValueDecl *VD);

    void RewriteBlockLiteralFunctionDecl(FunctionDecl *FD);

    void RewriteObjCQualifiedInterfaceTypes(Decl *Dcl);

    void RewriteTypeOfDecl(VarDecl *VD);

    void RewriteObjCQualifiedInterfaceTypes(Expr *E);

    std::string getIvarAccessString(ObjCIvarDecl *D);

    // Expression Rewriting.

    Stmt *RewriteFunctionBodyOrGlobalInitializer(Stmt *S);

    Stmt *RewriteAtEncode(ObjCEncodeExpr *Exp);

    Stmt *RewritePropertyOrImplicitGetter(PseudoObjectExpr *Pseudo);

    Stmt *RewritePropertyOrImplicitSetter(PseudoObjectExpr *Pseudo);

    Stmt *RewriteAtSelector(ObjCSelectorExpr *Exp);

    Stmt *RewriteMessageExpr(ObjCMessageExpr *Exp);

    Stmt *RewriteObjCStringLiteral(ObjCStringLiteral *Exp);

    Stmt *RewriteObjCBoolLiteralExpr(ObjCBoolLiteralExpr *Exp);

    Stmt *RewriteObjCBoxedExpr(ObjCBoxedExpr *Exp);

    Stmt *RewriteObjCArrayLiteralExpr(ObjCArrayLiteral *Exp);

    Stmt *RewriteObjCDictionaryLiteralExpr(ObjCDictionaryLiteral *Exp);

    Stmt *RewriteObjCProtocolExpr(ObjCProtocolExpr *Exp);

    Stmt *RewriteObjCTryStmt(ObjCAtTryStmt *S);

    Stmt *RewriteObjCAutoreleasePoolStmt(ObjCAutoreleasePoolStmt  *S);

    Stmt *RewriteObjCSynchronizedStmt(ObjCAtSynchronizedStmt *S);

    Stmt *RewriteObjCThrowStmt(ObjCAtThrowStmt *S);

    Stmt *RewriteObjCForCollectionStmt(ObjCForCollectionStmt *S,

                                       SourceLocation OrigEnd);

    Stmt *RewriteBreakStmt(BreakStmt *S);

    Stmt *RewriteContinueStmt(ContinueStmt *S);

    void RewriteCastExpr(CStyleCastExpr *CE);

    void RewriteImplicitCastObjCExpr(CastExpr *IE);

    // Computes ivar bitfield group no.

    unsigned ObjCIvarBitfieldGroupNo(ObjCIvarDecl *IV);

    // Names field decl. for ivar bitfield group.

    void ObjCIvarBitfieldGroupDecl(ObjCIvarDecl *IV, std::string &Result);

    // Names struct type for ivar bitfield group.

    void ObjCIvarBitfieldGroupType(ObjCIvarDecl *IV, std::string &Result);

    // Names symbol for ivar bitfield group field offset.

    void ObjCIvarBitfieldGroupOffset(ObjCIvarDecl *IV, std::string &Result);

    // Given an ivar bitfield, it builds (or finds) its group record type.

    QualType GetGroupRecordTypeForObjCIvarBitfield(ObjCIvarDecl *IV);

    QualType SynthesizeBitfieldGroupStructType(

                                    ObjCIvarDecl *IV,

                                    SmallVectorImpl<ObjCIvarDecl *> &IVars);

    // Block rewriting.

    void RewriteBlocksInFunctionProtoType(QualType funcType, NamedDecl *D);

    // Block specific rewrite rules.

    void RewriteBlockPointerDecl(NamedDecl *VD);

    void RewriteByRefVar(VarDecl *VD, bool firstDecl, bool lastDecl);

    Stmt *RewriteBlockDeclRefExpr(DeclRefExpr *VD);

    Stmt *RewriteLocalVariableExternalStorage(DeclRefExpr *DRE);

    void RewriteBlockPointerFunctionArgs(FunctionDecl *FD);

    void RewriteObjCInternalStruct(ObjCInterfaceDecl *CDecl,

                                      std::string &Result);

    void RewriteObjCFieldDecl(FieldDecl *fieldDecl, std::string &Result);

    bool IsTagDefinedInsideClass(ObjCContainerDecl *IDecl, TagDecl *Tag,

                                 bool &IsNamedDefinition);

    void RewriteLocallyDefinedNamedAggregates(FieldDecl *fieldDecl,

                                              std::string &Result);

    bool RewriteObjCFieldDeclType(QualType &Type, std::string &Result);

    void RewriteIvarOffsetSymbols(ObjCInterfaceDecl *CDecl,

                                  std::string &Result);

    void Initialize(ASTContext &context) override;

    // Misc. AST transformation routines. Sometimes they end up calling

    // rewriting routines on the new ASTs.

    CallExpr *SynthesizeCallToFunctionDecl(FunctionDecl *FD,

                                           ArrayRef<Expr *> Args,

                                           SourceLocation StartLoc=SourceLocation(),

                                           SourceLocation EndLoc=SourceLocation());

    Expr *SynthMsgSendStretCallExpr(FunctionDecl *MsgSendStretFlavor,

                                        QualType returnType,

                                        SmallVectorImpl<QualType> &ArgTypes,

                                        SmallVectorImpl<Expr*> &MsgExprs,

                                        ObjCMethodDecl *Method);

    Stmt *SynthMessageExpr(ObjCMessageExpr *Exp,

                           SourceLocation StartLoc=SourceLocation(),

                           SourceLocation EndLoc=SourceLocation());

    void SynthCountByEnumWithState(std::string &buf);

    void SynthMsgSendFunctionDecl();

    void SynthMsgSendSuperFunctionDecl();

    void SynthMsgSendStretFunctionDecl();

    void SynthMsgSendFpretFunctionDecl();

    void SynthMsgSendSuperStretFunctionDecl();

    void SynthGetClassFunctionDecl();

    void SynthGetMetaClassFunctionDecl();

    void SynthGetSuperClassFunctionDecl();

    void SynthSelGetUidFunctionDecl();

    void SynthSuperConstructorFunctionDecl();

    // Rewriting metadata

    template<typename MethodIterator>

    void RewriteObjCMethodsMetaData(MethodIterator MethodBegin,

                                    MethodIterator MethodEnd,

                                    bool IsInstanceMethod,

                                    StringRef prefix,

                                    StringRef ClassName,

                                    std::string &Result);

    void RewriteObjCProtocolMetaData(ObjCProtocolDecl *Protocol,

                                     std::string &Result);

    void RewriteObjCClassMetaData(ObjCImplementationDecl *IDecl,

                                          std::string &Result);

    void RewriteClassSetupInitHook(std::string &Result);

    void RewriteMetaDataIntoBuffer(std::string &Result);

    void WriteImageInfo(std::string &Result);

    void RewriteObjCCategoryImplDecl(ObjCCategoryImplDecl *CDecl,

                                             std::string &Result);

    void RewriteCategorySetupInitHook(std::string &Result);

    // Rewriting ivar

    void RewriteIvarOffsetComputation(ObjCIvarDecl *ivar,

                                              std::string &Result);

    Stmt *RewriteObjCIvarRefExpr(ObjCIvarRefExpr *IV);

    std::string SynthesizeByrefCopyDestroyHelper(VarDecl *VD, int flag);

    std::string SynthesizeBlockHelperFuncs(BlockExpr *CE, int i,

                                      StringRef funcName, std::string Tag);

    std::string SynthesizeBlockFunc(BlockExpr *CE, int i,

                                      StringRef funcName, std::string Tag);

    std::string SynthesizeBlockImpl(BlockExpr *CE,

                                    std::string Tag, std::string Desc);

    std::string SynthesizeBlockDescriptor(std::string DescTag,

                                          std::string ImplTag,

                                          int i, StringRef funcName,

                                          unsigned hasCopy);

    Stmt *SynthesizeBlockCall(CallExpr *Exp, const Expr* BlockExp);

    void SynthesizeBlockLiterals(SourceLocation FunLocStart,

                                 StringRef FunName);

    FunctionDecl *SynthBlockInitFunctionDecl(StringRef name);

    Stmt *SynthBlockInitExpr(BlockExpr *Exp,

                      const SmallVectorImpl<DeclRefExpr *> &InnerBlockDeclRefs);

    // Misc. helper routines.

    QualType getProtocolType();

    void WarnAboutReturnGotoStmts(Stmt *S);

    void CheckFunctionPointerDecl(QualType dType, NamedDecl *ND);

    void InsertBlockLiteralsWithinFunction(FunctionDecl *FD);

    void InsertBlockLiteralsWithinMethod(ObjCMethodDecl *MD);

    bool IsDeclStmtInForeachHeader(DeclStmt *DS);

    void CollectBlockDeclRefInfo(BlockExpr *Exp);

    void GetBlockDeclRefExprs(Stmt *S);

    void GetInnerBlockDeclRefExprs(Stmt *S,

                SmallVectorImpl<DeclRefExpr *> &InnerBlockDeclRefs,

                llvm::SmallPtrSetImpl<const DeclContext *> &InnerContexts);

    // We avoid calling Type::isBlockPointerType(), since it operates on the

    // canonical type. We only care if the top-level type is a closure pointer.

    bool isTopLevelBlockPointerType(QualType T) {

      return isa<BlockPointerType>(T);

    }

    /// convertBlockPointerToFunctionPointer - Converts a block-pointer type

    /// to a function pointer type and upon success, returns true; false

    /// otherwise.

    bool convertBlockPointerToFunctionPointer(QualType &T) {

      if (isTopLevelBlockPointerType(T)) {

        const auto *BPT = T->castAs<BlockPointerType>();

        T = Context->getPointerType(BPT->getPointeeType());

        return true;

      }

      return false;

    }

    bool convertObjCTypeToCStyleType(QualType &T);

    bool needToScanForQualifiers(QualType T);

    QualType getSuperStructType();

    QualType getConstantStringStructType();

    QualType convertFunctionTypeOfBlocks(const FunctionType *FT);

    void convertToUnqualifiedObjCType(QualType &T) {

      if (T->isObjCQualifiedIdType()) {

        bool isConst = T.isConstQualified();

        T = isConst ? 
Context->getObjCIdType().withConst()2

                    : 
Context->getObjCIdType()13
;

      }

      else if (T->isObjCQualifiedClassType())

        T = Context->getObjCClassType();

      else if (T->isObjCObjectPointerType() &&

               
T->getPointeeType()->isObjCQualifiedInterfaceType()134
) {

        if (const ObjCObjectPointerType * OBJPT =

              T->getAsObjCInterfacePointerType()) {

          const ObjCInterfaceType *IFaceT = OBJPT->getInterfaceType();

          T = QualType(IFaceT, 0);

          T = Context->getPointerType(T);

        }

     }

    }

    // FIXME: This predicate seems like it would be useful to add to ASTContext.

    bool isObjCType(QualType T) {

      if (!LangOpts.ObjC)

        return false;

      QualType OCT = Context->getCanonicalType(T).getUnqualifiedType();

      if (OCT == Context->getCanonicalType(Context->getObjCIdType()) ||

          
OCT == Context->getCanonicalType(Context->getObjCClassType())33
)

        return true;

      if (const PointerType *PT = OCT->getAs<PointerType>()) {

        if (isa<ObjCInterfaceType>(PT->getPointeeType()) ||

            PT->getPointeeType()->isObjCQualifiedIdType())

          return true;

      }

      return false;

    }

    bool PointerTypeTakesAnyBlockArguments(QualType QT);

    bool PointerTypeTakesAnyObjCQualifiedType(QualType QT);

    void GetExtentOfArgList(const char *Name, const char *&LParen,

                            const char *&RParen);

    void QuoteDoublequotes(std::string &From, std::string &To) {

      for (unsigned i = 0; i < From.length(); 
i++2.23k
) {

        if (From[i] == '"')

          To += "\\\"";

        else

          To += From[i];

      }

    }

    QualType getSimpleFunctionType(QualType result,

                                   ArrayRef<QualType> args,

                                   bool variadic = false) {

      if (result == Context->getObjCInstanceType())

        result =  Context->getObjCIdType();

      FunctionProtoType::ExtProtoInfo fpi;

      fpi.Variadic = variadic;

      return Context->getFunctionType(result, args, fpi);

    }

    // Helper function: create a CStyleCastExpr with trivial type source info.

    CStyleCastExpr* NoTypeInfoCStyleCastExpr(ASTContext *Ctx, QualType Ty,

                                             CastKind Kind, Expr *E) {

      TypeSourceInfo *TInfo = Ctx->getTrivialTypeSourceInfo(Ty, SourceLocation());

      return CStyleCastExpr::Create(*Ctx, Ty, VK_PRValue, Kind, E, nullptr,

                                    FPOptionsOverride(), TInfo,

                                    SourceLocation(), SourceLocation());

    }

    bool ImplementationIsNonLazy(const ObjCImplDecl *OD) const {

      IdentifierInfo* II = &Context->Idents.get("load");

      Selector LoadSel = Context->Selectors.getSelector(0, &II);

      return OD->getClassMethod(LoadSel) != nullptr;

    }

    StringLiteral *getStringLiteral(StringRef Str) {

      QualType StrType = Context->getConstantArrayType(

          Context->CharTy, llvm::APInt(32, Str.size() + 1), nullptr,

          ArrayType::Normal, 0);

      return StringLiteral::Create(*Context, Str, StringLiteral::Ordinary,

                                   /*Pascal=*/false, StrType, SourceLocation());

    }

  };

} // end anonymous namespace

void RewriteModernObjC::RewriteBlocksInFunctionProtoType(QualType funcType,

                                                   NamedDecl *D) {

  if (const FunctionProtoType *fproto

      = dyn_cast<FunctionProtoType>(funcType.IgnoreParens())) {

    for (const auto &I : fproto->param_types())

      if (isTopLevelBlockPointerType(I)) {

        // All the args are checked/rewritten. Don't call twice!

        RewriteBlockPointerDecl(D);

        break;

      }

  }

}

void RewriteModernObjC::CheckFunctionPointerDecl(QualType funcType, NamedDecl *ND) {

  const PointerType *PT = funcType->getAs<PointerType>();

  if (PT && PointerTypeTakesAnyBlockArguments(funcType))

    RewriteBlocksInFunctionProtoType(PT->getPointeeType(), ND);

}

static bool IsHeaderFile(const std::string &Filename) {

  std::string::size_type DotPos = Filename.rfind('.');

  if (DotPos == std::string::npos) {

    // no file extension

    return false;

  }

  std::string Ext = Filename.substr(DotPos + 1);

  // C header: .h

  // C++ header: .hh or .H;

  return Ext == "h" || Ext == "hh" || Ext == "H";

}

RewriteModernObjC::RewriteModernObjC(std::string inFile,

                                     std::unique_ptr<raw_ostream> OS,

                                     DiagnosticsEngine &D,

                                     const LangOptions &LOpts,

                                     bool silenceMacroWarn, bool LineInfo)

    : Diags(D), LangOpts(LOpts), InFileName(inFile), OutFile(std::move(OS)),

      SilenceRewriteMacroWarning(silenceMacroWarn), GenerateLineInfo(LineInfo) {

  IsHeader = IsHeaderFile(inFile);

  RewriteFailedDiag = Diags.getCustomDiagID(DiagnosticsEngine::Warning,

               "rewriting sub-expression within a macro (may not be correct)");

  // FIXME. This should be an error. But if block is not called, it is OK. And it

  // may break including some headers.

  GlobalBlockRewriteFailedDiag = Diags.getCustomDiagID(DiagnosticsEngine::Warning,

    "rewriting block literal declared in global scope is not implemented");

  TryFinallyContainsReturnDiag = Diags.getCustomDiagID(

               DiagnosticsEngine::Warning,

               "rewriter doesn't support user-specified control flow semantics "

               "for @try/@finally (code may not execute properly)");

}

std::unique_ptr<ASTConsumer> clang::CreateModernObjCRewriter(

    const std::string &InFile, std::unique_ptr<raw_ostream> OS,

    DiagnosticsEngine &Diags, const LangOptions &LOpts,

    bool SilenceRewriteMacroWarning, bool LineInfo) {

  return std::make_unique<RewriteModernObjC>(InFile, std::move(OS), Diags,

                                              LOpts, SilenceRewriteMacroWarning,

                                              LineInfo);

}

void RewriteModernObjC::InitializeCommon(ASTContext &context) {

  Context = &context;

  SM = &Context->getSourceManager();

  TUDecl = Context->getTranslationUnitDecl();

  MsgSendFunctionDecl = nullptr;

  MsgSendSuperFunctionDecl = nullptr;

  MsgSendStretFunctionDecl = nullptr;

  MsgSendSuperStretFunctionDecl = nullptr;

  MsgSendFpretFunctionDecl = nullptr;

  GetClassFunctionDecl = nullptr;

  GetMetaClassFunctionDecl = nullptr;

  GetSuperClassFunctionDecl = nullptr;

  SelGetUidFunctionDecl = nullptr;

  CFStringFunctionDecl = nullptr;

  ConstantStringClassReference = nullptr;

  NSStringRecord = nullptr;

  CurMethodDef = nullptr;

  CurFunctionDef = nullptr;

  GlobalVarDecl = nullptr;

  GlobalConstructionExp = nullptr;

  SuperStructDecl = nullptr;

  ProtocolTypeDecl = nullptr;

  ConstantStringDecl = nullptr;

  BcLabelCount = 0;

  SuperConstructorFunctionDecl = nullptr;

  NumObjCStringLiterals = 0;

  PropParentMap = nullptr;

  CurrentBody = nullptr;

  DisableReplaceStmt = false;

  objc_impl_method = false;

  // Get the ID and start/end of the main file.

  MainFileID = SM->getMainFileID();

  llvm::MemoryBufferRef MainBuf = SM->getBufferOrFake(MainFileID);

  MainFileStart = MainBuf.getBufferStart();

  MainFileEnd = MainBuf.getBufferEnd();

  Rewrite.setSourceMgr(Context->getSourceManager(), Context->getLangOpts());

}

//===----------------------------------------------------------------------===//

// Top Level Driver Code

//===----------------------------------------------------------------------===//

void RewriteModernObjC::HandleTopLevelSingleDecl(Decl *D) {

  if (Diags.hasErrorOccurred())

    return;

  // Two cases: either the decl could be in the main file, or it could be in a

  // #included file.  If the former, rewrite it now.  If the later, check to see

  // if we rewrote the #include/#import.

  SourceLocation Loc = D->getLocation();

  Loc = SM->getExpansionLoc(Loc);

  // If this is for a builtin, ignore it.

  if (Loc.isInvalid()) 
return0
;

  // Look for built-in declarations that we need to refer during the rewrite.

  if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {

    RewriteFunctionDecl(FD);

  } else if (VarDecl *FVD = dyn_cast<VarDecl>(D)) {

    // declared in <Foundation/NSString.h>

    if (FVD->getName() == "_NSConstantStringClassReference") {

      ConstantStringClassReference = FVD;

      return;

    }

  } else if (ObjCCategoryDecl *CD = dyn_cast<ObjCCategoryDecl>(D)) {

    RewriteCategoryDecl(CD);

  } else if (ObjCProtocolDecl *PD = dyn_cast<ObjCProtocolDecl>(D)) {

    if (PD->isThisDeclarationADefinition())

      RewriteProtocolDecl(PD);

  } else if (LinkageSpecDecl *LSD = dyn_cast<LinkageSpecDecl>(D)) {

    // Recurse into linkage specifications

    for (DeclContext::decl_iterator DI = LSD->decls_begin(),

                                 DIEnd = LSD->decls_end();

         DI != DIEnd; ) {

      if (ObjCInterfaceDecl *IFace = dyn_cast<ObjCInterfaceDecl>((*DI))) {

        if (!IFace->isThisDeclarationADefinition()) {

          SmallVector<Decl *, 8> DG;

          SourceLocation StartLoc = IFace->getBeginLoc();

          do {

            if (isa<ObjCInterfaceDecl>(*DI) &&

                
!cast<ObjCInterfaceDecl>(*DI)->isThisDeclarationADefinition()20
 &&

                
StartLoc == (*DI)->getBeginLoc()19
)

              DG.push_back(*DI);

            else

              break;

            ++DI;

          } while (DI != DIEnd);

          RewriteForwardClassDecl(DG);

          continue;

        }

        else {

          // Keep track of all interface declarations seen.

          ObjCInterfacesSeen.push_back(IFace);

          ++DI;

          continue;

        }

      }

      if (ObjCProtocolDecl *Proto = dyn_cast<ObjCProtocolDecl>((*DI))) {

        if (!Proto->isThisDeclarationADefinition()) {

          SmallVector<Decl *, 8> DG;

          SourceLocation StartLoc = Proto->getBeginLoc();

          do {

            if (isa<ObjCProtocolDecl>(*DI) &&

                !cast<ObjCProtocolDecl>(*DI)->isThisDeclarationADefinition() &&

                StartLoc == (*DI)->getBeginLoc())

              DG.push_back(*DI);

            else

              break;

            ++DI;

          } while (DI != DIEnd);

          RewriteForwardProtocolDecl(DG);

          continue;

        }

      }

      HandleTopLevelSingleDecl(*DI);

      ++DI;

    }

  }

  // If we have a decl in the main file, see if we should rewrite it.

  if (SM->isWrittenInMainFile(Loc))

    return HandleDeclInMainFile(D);

}

//===----------------------------------------------------------------------===//

// Syntactic (non-AST) Rewriting Code

//===----------------------------------------------------------------------===//

void RewriteModernObjC::RewriteInclude() {

  SourceLocation LocStart = SM->getLocForStartOfFile(MainFileID);

  StringRef MainBuf = SM->getBufferData(MainFileID);

  const char *MainBufStart = MainBuf.begin();

  const char *MainBufEnd = MainBuf.end();

  size_t ImportLen = strlen("import");

  // Loop over the whole file, looking for includes.

  for (const char *BufPtr = MainBufStart; BufPtr < MainBufEnd; 
++BufPtr80.3k
) {

    if (*BufPtr == '#') {

      if (++BufPtr == MainBufEnd)

        return;

      
while (182
*BufPtr == ' ' || 
*BufPtr == '\t'182
)

        if (++BufPtr == MainBufEnd)

          return;

      if (!strncmp(BufPtr, "import", ImportLen)) {

        // replace import with include

        SourceLocation ImportLoc =

          LocStart.getLocWithOffset(BufPtr-MainBufStart);

        ReplaceText(ImportLoc, ImportLen, "include");

        BufPtr += ImportLen;

      }

    }

  }

}

static void WriteInternalIvarName(const ObjCInterfaceDecl *IDecl,

                                  ObjCIvarDecl *IvarDecl, std::string &Result) {

  Result += "OBJC_IVAR_$_";

  Result += IDecl->getName();

  Result += "$";

  Result += IvarDecl->getName();

}

std::string

RewriteModernObjC::getIvarAccessString(ObjCIvarDecl *D) {

  const ObjCInterfaceDecl *ClassDecl = D->getContainingInterface();

  // Build name of symbol holding ivar offset.

  std::string IvarOffsetName;

  if (D->isBitField())

    ObjCIvarBitfieldGroupOffset(D, IvarOffsetName);

  else

    WriteInternalIvarName(ClassDecl, D, IvarOffsetName);

  std::string S = "(*(";

  QualType IvarT = D->getType();

  if (D->isBitField())

    IvarT = GetGroupRecordTypeForObjCIvarBitfield(D);

  if (!IvarT->getAs<TypedefType>() && 
IvarT->isRecordType()19
) {

    RecordDecl *RD = IvarT->castAs<RecordType>()->getDecl();

    RD = RD->getDefinition();

    if (RD && !RD->getDeclName().getAsIdentifierInfo()) {

      // decltype(((Foo_IMPL*)0)->bar) *

      auto *CDecl = cast<ObjCContainerDecl>(D->getDeclContext());

      // ivar in class extensions requires special treatment.

      if (ObjCCategoryDecl *CatDecl = dyn_cast<ObjCCategoryDecl>(CDecl))

        CDecl = CatDecl->getClassInterface();

      std::string RecName = std::string(CDecl->getName());

      RecName += "_IMPL";

      RecordDecl *RD =

          RecordDecl::Create(*Context, TTK_Struct, TUDecl, SourceLocation(),

                             SourceLocation(), &Context->Idents.get(RecName));

      QualType PtrStructIMPL = Context->getPointerType(Context->getTagDeclType(RD));

      unsigned UnsignedIntSize =

      static_cast<unsigned>(Context->getTypeSize(Context->UnsignedIntTy));

      Expr *Zero = IntegerLiteral::Create(*Context,

                                          llvm::APInt(UnsignedIntSize, 0),

                                          Context->UnsignedIntTy, SourceLocation());

      Zero = NoTypeInfoCStyleCastExpr(Context, PtrStructIMPL, CK_BitCast, Zero);

      ParenExpr *PE = new (Context) ParenExpr(SourceLocation(), SourceLocation(),

                                              Zero);

      FieldDecl *FD = FieldDecl::Create(*Context, nullptr, SourceLocation(),

                                        SourceLocation(),

                                        &Context->Idents.get(D->getNameAsString()),

                                        IvarT, nullptr,

                                        /*BitWidth=*/nullptr, /*Mutable=*/true,

                                        ICIS_NoInit);

      MemberExpr *ME = MemberExpr::CreateImplicit(

          *Context, PE, true, FD, FD->getType(), VK_LValue, OK_Ordinary);

      IvarT = Context->getDecltypeType(ME, ME->getType());

    }

  }

  convertObjCTypeToCStyleType(IvarT);

  QualType castT = Context->getPointerType(IvarT);

  std::string TypeString(castT.getAsString(Context->getPrintingPolicy()));

  S += TypeString;

  S += ")";

  // ((char *)self + IVAR_OFFSET_SYMBOL_NAME)

  S += "((char *)self + ";

  S += IvarOffsetName;

  S += "))";

  if (D->isBitField()) {

    S += ".";

    S += D->getNameAsString();

  }

  ReferencedIvars[const_cast<ObjCInterfaceDecl *>(ClassDecl)].insert(D);

  return S;

}

/// mustSynthesizeSetterGetterMethod - returns true if setter or getter has not

/// been found in the class implementation. In this case, it must be synthesized.

static bool mustSynthesizeSetterGetterMethod(ObjCImplementationDecl *IMP,

                                             ObjCPropertyDecl *PD,

                                             bool getter) {

  auto *OMD = IMP->getInstanceMethod(getter ? 
PD->getGetterName()56

                                            : 
PD->getSetterName()48
);

  return !OMD || OMD->isSynthesizedAccessorStub();

}

void RewriteModernObjC::RewritePropertyImplDecl(ObjCPropertyImplDecl *PID,

                                          ObjCImplementationDecl *IMD,

                                          ObjCCategoryImplDecl *CID) {

  static bool objcGetPropertyDefined = false;

  static bool objcSetPropertyDefined = false;

  SourceLocation startGetterSetterLoc;

  if (PID->getBeginLoc().isValid()) {

    SourceLocation startLoc = PID->getBeginLoc();

    InsertText(startLoc, "// ");

    const char *startBuf = SM->getCharacterData(startLoc);

    assert((*startBuf == '@') && "bogus @synthesize location");

    const char *semiBuf = strchr(startBuf, ';');

    assert((*semiBuf == ';') && "@synthesize: can't find ';'");

    startGetterSetterLoc = startLoc.getLocWithOffset(semiBuf-startBuf+1);

  } else

    startGetterSetterLoc = IMD ? IMD->getEndLoc() : 
CID->getEndLoc()0
;

  if (PID->getPropertyImplementation() == ObjCPropertyImplDecl::Dynamic)

    return; // FIXME: is this correct?

  // Generate the 'getter' function.

  ObjCPropertyDecl *PD = PID->getPropertyDecl();

  ObjCIvarDecl *OID = PID->getPropertyIvarDecl();

  assert(IMD && OID && "Synthesized ivars must be attached to @implementation");

  unsigned Attributes = PD->getPropertyAttributes();

  if (mustSynthesizeSetterGetterMethod(IMD, PD, true /*getter*/)) {

    bool GenGetProperty =

        !(Attributes & ObjCPropertyAttribute::kind_nonatomic) &&

        (Attributes & (ObjCPropertyAttribute::kind_retain |

                       ObjCPropertyAttribute::kind_copy));

    std::string Getr;

    if (GenGetProperty && 
!objcGetPropertyDefined9
) {

      objcGetPropertyDefined = true;

      // FIXME. Is this attribute correct in all cases?

      Getr = "\nextern \"C\" __declspec(dllimport) "

            "id objc_getProperty(id, SEL, long, bool);\n";

    }

    RewriteObjCMethodDecl(OID->getContainingInterface(),

                          PID->getGetterMethodDecl(), Getr);

    Getr += "{ ";

    // Synthesize an explicit cast to gain access to the ivar.

    // See objc-act.c:objc_synthesize_new_getter() for details.

    if (GenGetProperty) {

      // return objc_getProperty(self, _cmd, offsetof(ClassDecl, OID), 1)

      Getr += "typedef ";

      const FunctionType *FPRetType = nullptr;

      RewriteTypeIntoString(PID->getGetterMethodDecl()->getReturnType(), Getr,

                            FPRetType);

      Getr += " _TYPE";

      if (FPRetType) {

        Getr += ")"; // close the precedence "scope" for "*".

        // Now, emit the argument types (if any).

        if (const FunctionProtoType *FT = dyn_cast<FunctionProtoType>(FPRetType)){

          Getr += "(";

          for (unsigned i = 0, e = FT->getNumParams(); i != e; 
++i0
) {

            if (i) Getr += ", ";

            std::string ParamStr =

                FT->getParamType(i).getAsString(Context->getPrintingPolicy());

            Getr += ParamStr;

          }

          if (FT->isVariadic()) {

            if (FT->getNumParams())

              Getr += ", ";

            Getr += "...";

          }

          Getr += ")";

        } else

          Getr += "()";

      }

      Getr += ";\n";

      Getr += "return (_TYPE)";

      Getr += "objc_getProperty(self, _cmd, ";

      RewriteIvarOffsetComputation(OID, Getr);

      Getr += ", 1)";

    }

    else

      Getr += "return " + getIvarAccessString(OID);

    Getr += "; }";

    InsertText(startGetterSetterLoc, Getr);

  }

  if (PD->isReadOnly() ||

      
!mustSynthesizeSetterGetterMethod(IMD, PD, false /*setter*/)24
)

    return;

  // Generate the 'setter' function.

  std::string Setr;

  bool GenSetProperty = Attributes & (ObjCPropertyAttribute::kind_retain |

                                      ObjCPropertyAttribute::kind_copy);

  if (GenSetProperty && 
!objcSetPropertyDefined9
) {

    objcSetPropertyDefined = true;

    // FIXME. Is this attribute correct in all cases?

    Setr = "\nextern \"C\" __declspec(dllimport) "

    "void objc_setProperty (id, SEL, long, id, bool, bool);\n";

  }

  RewriteObjCMethodDecl(OID->getContainingInterface(),

                        PID->getSetterMethodDecl(), Setr);

  Setr += "{ ";

  // Synthesize an explicit cast to initialize the ivar.

  // See objc-act.c:objc_synthesize_new_setter() for details.

  if (GenSetProperty) {

    Setr += "objc_setProperty (self, _cmd, ";

    RewriteIvarOffsetComputation(OID, Setr);

    Setr += ", (id)";

    Setr += PD->getName();

    Setr += ", ";

    if (Attributes & ObjCPropertyAttribute::kind_nonatomic)

      Setr += "0, ";

    else

      Setr += "1, ";

    if (Attributes & ObjCPropertyAttribute::kind_copy)

      Setr += "1)";

    else

      Setr += "0)";

  }

  else {

    Setr += getIvarAccessString(OID) + " = ";

    Setr += PD->getName();

  }

  Setr += "; }\n";