• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1  //===--- Transforms.cpp - Transformations to ARC mode ---------------------===//
2  //
3  //                     The LLVM Compiler Infrastructure
4  //
5  // This file is distributed under the University of Illinois Open Source
6  // License. See LICENSE.TXT for details.
7  //
8  //===----------------------------------------------------------------------===//
9  
10  #include "Transforms.h"
11  #include "Internals.h"
12  #include "clang/AST/ASTContext.h"
13  #include "clang/AST/RecursiveASTVisitor.h"
14  #include "clang/AST/StmtVisitor.h"
15  #include "clang/Analysis/DomainSpecific/CocoaConventions.h"
16  #include "clang/Basic/SourceManager.h"
17  #include "clang/Basic/TargetInfo.h"
18  #include "clang/Lex/Lexer.h"
19  #include "clang/Sema/Sema.h"
20  #include "clang/Sema/SemaDiagnostic.h"
21  #include "llvm/ADT/DenseSet.h"
22  #include "llvm/ADT/StringSwitch.h"
23  #include <map>
24  
25  using namespace clang;
26  using namespace arcmt;
27  using namespace trans;
28  
~ASTTraverser()29  ASTTraverser::~ASTTraverser() { }
30  
CFBridgingFunctionsDefined()31  bool MigrationPass::CFBridgingFunctionsDefined() {
32    if (!EnableCFBridgeFns.hasValue())
33      EnableCFBridgeFns = SemaRef.isKnownName("CFBridgingRetain") &&
34                          SemaRef.isKnownName("CFBridgingRelease");
35    return *EnableCFBridgeFns;
36  }
37  
38  //===----------------------------------------------------------------------===//
39  // Helpers.
40  //===----------------------------------------------------------------------===//
41  
canApplyWeak(ASTContext & Ctx,QualType type,bool AllowOnUnknownClass)42  bool trans::canApplyWeak(ASTContext &Ctx, QualType type,
43                           bool AllowOnUnknownClass) {
44    if (!Ctx.getLangOpts().ObjCARCWeak)
45      return false;
46  
47    QualType T = type;
48    if (T.isNull())
49      return false;
50  
51    // iOS is always safe to use 'weak'.
52    if (Ctx.getTargetInfo().getTriple().getOS() == llvm::Triple::IOS)
53      AllowOnUnknownClass = true;
54  
55    while (const PointerType *ptr = T->getAs<PointerType>())
56      T = ptr->getPointeeType();
57    if (const ObjCObjectPointerType *ObjT = T->getAs<ObjCObjectPointerType>()) {
58      ObjCInterfaceDecl *Class = ObjT->getInterfaceDecl();
59      if (!AllowOnUnknownClass && (!Class || Class->getName() == "NSObject"))
60        return false; // id/NSObject is not safe for weak.
61      if (!AllowOnUnknownClass && !Class->hasDefinition())
62        return false; // forward classes are not verifiable, therefore not safe.
63      if (Class && Class->isArcWeakrefUnavailable())
64        return false;
65    }
66  
67    return true;
68  }
69  
isPlusOneAssign(const BinaryOperator * E)70  bool trans::isPlusOneAssign(const BinaryOperator *E) {
71    if (E->getOpcode() != BO_Assign)
72      return false;
73  
74    return isPlusOne(E->getRHS());
75  }
76  
isPlusOne(const Expr * E)77  bool trans::isPlusOne(const Expr *E) {
78    if (!E)
79      return false;
80    if (const ExprWithCleanups *EWC = dyn_cast<ExprWithCleanups>(E))
81      E = EWC->getSubExpr();
82  
83    if (const ObjCMessageExpr *
84          ME = dyn_cast<ObjCMessageExpr>(E->IgnoreParenCasts()))
85      if (ME->getMethodFamily() == OMF_retain)
86        return true;
87  
88    if (const CallExpr *
89          callE = dyn_cast<CallExpr>(E->IgnoreParenCasts())) {
90      if (const FunctionDecl *FD = callE->getDirectCallee()) {
91        if (FD->getAttr<CFReturnsRetainedAttr>())
92          return true;
93  
94        if (FD->isGlobal() &&
95            FD->getIdentifier() &&
96            FD->getParent()->isTranslationUnit() &&
97            FD->isExternallyVisible() &&
98            ento::cocoa::isRefType(callE->getType(), "CF",
99                                   FD->getIdentifier()->getName())) {
100          StringRef fname = FD->getIdentifier()->getName();
101          if (fname.endswith("Retain") ||
102              fname.find("Create") != StringRef::npos ||
103              fname.find("Copy") != StringRef::npos) {
104            return true;
105          }
106        }
107      }
108    }
109  
110    const ImplicitCastExpr *implCE = dyn_cast<ImplicitCastExpr>(E);
111    while (implCE && implCE->getCastKind() ==  CK_BitCast)
112      implCE = dyn_cast<ImplicitCastExpr>(implCE->getSubExpr());
113  
114    if (implCE && implCE->getCastKind() == CK_ARCConsumeObject)
115      return true;
116  
117    return false;
118  }
119  
120  /// \brief 'Loc' is the end of a statement range. This returns the location
121  /// immediately after the semicolon following the statement.
122  /// If no semicolon is found or the location is inside a macro, the returned
123  /// source location will be invalid.
findLocationAfterSemi(SourceLocation loc,ASTContext & Ctx)124  SourceLocation trans::findLocationAfterSemi(SourceLocation loc,
125                                              ASTContext &Ctx) {
126    SourceLocation SemiLoc = findSemiAfterLocation(loc, Ctx);
127    if (SemiLoc.isInvalid())
128      return SourceLocation();
129    return SemiLoc.getLocWithOffset(1);
130  }
131  
132  /// \brief \arg Loc is the end of a statement range. This returns the location
133  /// of the semicolon following the statement.
134  /// If no semicolon is found or the location is inside a macro, the returned
135  /// source location will be invalid.
findSemiAfterLocation(SourceLocation loc,ASTContext & Ctx)136  SourceLocation trans::findSemiAfterLocation(SourceLocation loc,
137                                              ASTContext &Ctx) {
138    SourceManager &SM = Ctx.getSourceManager();
139    if (loc.isMacroID()) {
140      if (!Lexer::isAtEndOfMacroExpansion(loc, SM, Ctx.getLangOpts(), &loc))
141        return SourceLocation();
142    }
143    loc = Lexer::getLocForEndOfToken(loc, /*Offset=*/0, SM, Ctx.getLangOpts());
144  
145    // Break down the source location.
146    std::pair<FileID, unsigned> locInfo = SM.getDecomposedLoc(loc);
147  
148    // Try to load the file buffer.
149    bool invalidTemp = false;
150    StringRef file = SM.getBufferData(locInfo.first, &invalidTemp);
151    if (invalidTemp)
152      return SourceLocation();
153  
154    const char *tokenBegin = file.data() + locInfo.second;
155  
156    // Lex from the start of the given location.
157    Lexer lexer(SM.getLocForStartOfFile(locInfo.first),
158                Ctx.getLangOpts(),
159                file.begin(), tokenBegin, file.end());
160    Token tok;
161    lexer.LexFromRawLexer(tok);
162    if (tok.isNot(tok::semi))
163      return SourceLocation();
164  
165    return tok.getLocation();
166  }
167  
hasSideEffects(Expr * E,ASTContext & Ctx)168  bool trans::hasSideEffects(Expr *E, ASTContext &Ctx) {
169    if (!E || !E->HasSideEffects(Ctx))
170      return false;
171  
172    E = E->IgnoreParenCasts();
173    ObjCMessageExpr *ME = dyn_cast<ObjCMessageExpr>(E);
174    if (!ME)
175      return true;
176    switch (ME->getMethodFamily()) {
177    case OMF_autorelease:
178    case OMF_dealloc:
179    case OMF_release:
180    case OMF_retain:
181      switch (ME->getReceiverKind()) {
182      case ObjCMessageExpr::SuperInstance:
183        return false;
184      case ObjCMessageExpr::Instance:
185        return hasSideEffects(ME->getInstanceReceiver(), Ctx);
186      default:
187        break;
188      }
189      break;
190    default:
191      break;
192    }
193  
194    return true;
195  }
196  
isGlobalVar(Expr * E)197  bool trans::isGlobalVar(Expr *E) {
198    E = E->IgnoreParenCasts();
199    if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E))
200      return DRE->getDecl()->getDeclContext()->isFileContext() &&
201             DRE->getDecl()->isExternallyVisible();
202    if (ConditionalOperator *condOp = dyn_cast<ConditionalOperator>(E))
203      return isGlobalVar(condOp->getTrueExpr()) &&
204             isGlobalVar(condOp->getFalseExpr());
205  
206    return false;
207  }
208  
getNilString(ASTContext & Ctx)209  StringRef trans::getNilString(ASTContext &Ctx) {
210    if (Ctx.Idents.get("nil").hasMacroDefinition())
211      return "nil";
212    else
213      return "0";
214  }
215  
216  namespace {
217  
218  class ReferenceClear : public RecursiveASTVisitor<ReferenceClear> {
219    ExprSet &Refs;
220  public:
ReferenceClear(ExprSet & refs)221    ReferenceClear(ExprSet &refs) : Refs(refs) { }
VisitDeclRefExpr(DeclRefExpr * E)222    bool VisitDeclRefExpr(DeclRefExpr *E) { Refs.erase(E); return true; }
223  };
224  
225  class ReferenceCollector : public RecursiveASTVisitor<ReferenceCollector> {
226    ValueDecl *Dcl;
227    ExprSet &Refs;
228  
229  public:
ReferenceCollector(ValueDecl * D,ExprSet & refs)230    ReferenceCollector(ValueDecl *D, ExprSet &refs)
231      : Dcl(D), Refs(refs) { }
232  
VisitDeclRefExpr(DeclRefExpr * E)233    bool VisitDeclRefExpr(DeclRefExpr *E) {
234      if (E->getDecl() == Dcl)
235        Refs.insert(E);
236      return true;
237    }
238  };
239  
240  class RemovablesCollector : public RecursiveASTVisitor<RemovablesCollector> {
241    ExprSet &Removables;
242  
243  public:
RemovablesCollector(ExprSet & removables)244    RemovablesCollector(ExprSet &removables)
245    : Removables(removables) { }
246  
shouldWalkTypesOfTypeLocs() const247    bool shouldWalkTypesOfTypeLocs() const { return false; }
248  
TraverseStmtExpr(StmtExpr * E)249    bool TraverseStmtExpr(StmtExpr *E) {
250      CompoundStmt *S = E->getSubStmt();
251      for (CompoundStmt::body_iterator
252          I = S->body_begin(), E = S->body_end(); I != E; ++I) {
253        if (I != E - 1)
254          mark(*I);
255        TraverseStmt(*I);
256      }
257      return true;
258    }
259  
VisitCompoundStmt(CompoundStmt * S)260    bool VisitCompoundStmt(CompoundStmt *S) {
261      for (CompoundStmt::body_iterator
262          I = S->body_begin(), E = S->body_end(); I != E; ++I)
263        mark(*I);
264      return true;
265    }
266  
VisitIfStmt(IfStmt * S)267    bool VisitIfStmt(IfStmt *S) {
268      mark(S->getThen());
269      mark(S->getElse());
270      return true;
271    }
272  
VisitWhileStmt(WhileStmt * S)273    bool VisitWhileStmt(WhileStmt *S) {
274      mark(S->getBody());
275      return true;
276    }
277  
VisitDoStmt(DoStmt * S)278    bool VisitDoStmt(DoStmt *S) {
279      mark(S->getBody());
280      return true;
281    }
282  
VisitForStmt(ForStmt * S)283    bool VisitForStmt(ForStmt *S) {
284      mark(S->getInit());
285      mark(S->getInc());
286      mark(S->getBody());
287      return true;
288    }
289  
290  private:
mark(Stmt * S)291    void mark(Stmt *S) {
292      if (!S) return;
293  
294      while (LabelStmt *Label = dyn_cast<LabelStmt>(S))
295        S = Label->getSubStmt();
296      S = S->IgnoreImplicit();
297      if (Expr *E = dyn_cast<Expr>(S))
298        Removables.insert(E);
299    }
300  };
301  
302  } // end anonymous namespace
303  
clearRefsIn(Stmt * S,ExprSet & refs)304  void trans::clearRefsIn(Stmt *S, ExprSet &refs) {
305    ReferenceClear(refs).TraverseStmt(S);
306  }
307  
collectRefs(ValueDecl * D,Stmt * S,ExprSet & refs)308  void trans::collectRefs(ValueDecl *D, Stmt *S, ExprSet &refs) {
309    ReferenceCollector(D, refs).TraverseStmt(S);
310  }
311  
collectRemovables(Stmt * S,ExprSet & exprs)312  void trans::collectRemovables(Stmt *S, ExprSet &exprs) {
313    RemovablesCollector(exprs).TraverseStmt(S);
314  }
315  
316  //===----------------------------------------------------------------------===//
317  // MigrationContext
318  //===----------------------------------------------------------------------===//
319  
320  namespace {
321  
322  class ASTTransform : public RecursiveASTVisitor<ASTTransform> {
323    MigrationContext &MigrateCtx;
324    typedef RecursiveASTVisitor<ASTTransform> base;
325  
326  public:
ASTTransform(MigrationContext & MigrateCtx)327    ASTTransform(MigrationContext &MigrateCtx) : MigrateCtx(MigrateCtx) { }
328  
shouldWalkTypesOfTypeLocs() const329    bool shouldWalkTypesOfTypeLocs() const { return false; }
330  
TraverseObjCImplementationDecl(ObjCImplementationDecl * D)331    bool TraverseObjCImplementationDecl(ObjCImplementationDecl *D) {
332      ObjCImplementationContext ImplCtx(MigrateCtx, D);
333      for (MigrationContext::traverser_iterator
334             I = MigrateCtx.traversers_begin(),
335             E = MigrateCtx.traversers_end(); I != E; ++I)
336        (*I)->traverseObjCImplementation(ImplCtx);
337  
338      return base::TraverseObjCImplementationDecl(D);
339    }
340  
TraverseStmt(Stmt * rootS)341    bool TraverseStmt(Stmt *rootS) {
342      if (!rootS)
343        return true;
344  
345      BodyContext BodyCtx(MigrateCtx, rootS);
346      for (MigrationContext::traverser_iterator
347             I = MigrateCtx.traversers_begin(),
348             E = MigrateCtx.traversers_end(); I != E; ++I)
349        (*I)->traverseBody(BodyCtx);
350  
351      return true;
352    }
353  };
354  
355  }
356  
~MigrationContext()357  MigrationContext::~MigrationContext() {
358    for (traverser_iterator
359           I = traversers_begin(), E = traversers_end(); I != E; ++I)
360      delete *I;
361  }
362  
isGCOwnedNonObjC(QualType T)363  bool MigrationContext::isGCOwnedNonObjC(QualType T) {
364    while (!T.isNull()) {
365      if (const AttributedType *AttrT = T->getAs<AttributedType>()) {
366        if (AttrT->getAttrKind() == AttributedType::attr_objc_ownership)
367          return !AttrT->getModifiedType()->isObjCRetainableType();
368      }
369  
370      if (T->isArrayType())
371        T = Pass.Ctx.getBaseElementType(T);
372      else if (const PointerType *PT = T->getAs<PointerType>())
373        T = PT->getPointeeType();
374      else if (const ReferenceType *RT = T->getAs<ReferenceType>())
375        T = RT->getPointeeType();
376      else
377        break;
378    }
379  
380    return false;
381  }
382  
rewritePropertyAttribute(StringRef fromAttr,StringRef toAttr,SourceLocation atLoc)383  bool MigrationContext::rewritePropertyAttribute(StringRef fromAttr,
384                                                  StringRef toAttr,
385                                                  SourceLocation atLoc) {
386    if (atLoc.isMacroID())
387      return false;
388  
389    SourceManager &SM = Pass.Ctx.getSourceManager();
390  
391    // Break down the source location.
392    std::pair<FileID, unsigned> locInfo = SM.getDecomposedLoc(atLoc);
393  
394    // Try to load the file buffer.
395    bool invalidTemp = false;
396    StringRef file = SM.getBufferData(locInfo.first, &invalidTemp);
397    if (invalidTemp)
398      return false;
399  
400    const char *tokenBegin = file.data() + locInfo.second;
401  
402    // Lex from the start of the given location.
403    Lexer lexer(SM.getLocForStartOfFile(locInfo.first),
404                Pass.Ctx.getLangOpts(),
405                file.begin(), tokenBegin, file.end());
406    Token tok;
407    lexer.LexFromRawLexer(tok);
408    if (tok.isNot(tok::at)) return false;
409    lexer.LexFromRawLexer(tok);
410    if (tok.isNot(tok::raw_identifier)) return false;
411    if (StringRef(tok.getRawIdentifierData(), tok.getLength())
412          != "property")
413      return false;
414    lexer.LexFromRawLexer(tok);
415    if (tok.isNot(tok::l_paren)) return false;
416  
417    Token BeforeTok = tok;
418    Token AfterTok;
419    AfterTok.startToken();
420    SourceLocation AttrLoc;
421  
422    lexer.LexFromRawLexer(tok);
423    if (tok.is(tok::r_paren))
424      return false;
425  
426    while (1) {
427      if (tok.isNot(tok::raw_identifier)) return false;
428      StringRef ident(tok.getRawIdentifierData(), tok.getLength());
429      if (ident == fromAttr) {
430        if (!toAttr.empty()) {
431          Pass.TA.replaceText(tok.getLocation(), fromAttr, toAttr);
432          return true;
433        }
434        // We want to remove the attribute.
435        AttrLoc = tok.getLocation();
436      }
437  
438      do {
439        lexer.LexFromRawLexer(tok);
440        if (AttrLoc.isValid() && AfterTok.is(tok::unknown))
441          AfterTok = tok;
442      } while (tok.isNot(tok::comma) && tok.isNot(tok::r_paren));
443      if (tok.is(tok::r_paren))
444        break;
445      if (AttrLoc.isInvalid())
446        BeforeTok = tok;
447      lexer.LexFromRawLexer(tok);
448    }
449  
450    if (toAttr.empty() && AttrLoc.isValid() && AfterTok.isNot(tok::unknown)) {
451      // We want to remove the attribute.
452      if (BeforeTok.is(tok::l_paren) && AfterTok.is(tok::r_paren)) {
453        Pass.TA.remove(SourceRange(BeforeTok.getLocation(),
454                                   AfterTok.getLocation()));
455      } else if (BeforeTok.is(tok::l_paren) && AfterTok.is(tok::comma)) {
456        Pass.TA.remove(SourceRange(AttrLoc, AfterTok.getLocation()));
457      } else {
458        Pass.TA.remove(SourceRange(BeforeTok.getLocation(), AttrLoc));
459      }
460  
461      return true;
462    }
463  
464    return false;
465  }
466  
addPropertyAttribute(StringRef attr,SourceLocation atLoc)467  bool MigrationContext::addPropertyAttribute(StringRef attr,
468                                              SourceLocation atLoc) {
469    if (atLoc.isMacroID())
470      return false;
471  
472    SourceManager &SM = Pass.Ctx.getSourceManager();
473  
474    // Break down the source location.
475    std::pair<FileID, unsigned> locInfo = SM.getDecomposedLoc(atLoc);
476  
477    // Try to load the file buffer.
478    bool invalidTemp = false;
479    StringRef file = SM.getBufferData(locInfo.first, &invalidTemp);
480    if (invalidTemp)
481      return false;
482  
483    const char *tokenBegin = file.data() + locInfo.second;
484  
485    // Lex from the start of the given location.
486    Lexer lexer(SM.getLocForStartOfFile(locInfo.first),
487                Pass.Ctx.getLangOpts(),
488                file.begin(), tokenBegin, file.end());
489    Token tok;
490    lexer.LexFromRawLexer(tok);
491    if (tok.isNot(tok::at)) return false;
492    lexer.LexFromRawLexer(tok);
493    if (tok.isNot(tok::raw_identifier)) return false;
494    if (StringRef(tok.getRawIdentifierData(), tok.getLength())
495          != "property")
496      return false;
497    lexer.LexFromRawLexer(tok);
498  
499    if (tok.isNot(tok::l_paren)) {
500      Pass.TA.insert(tok.getLocation(), std::string("(") + attr.str() + ") ");
501      return true;
502    }
503  
504    lexer.LexFromRawLexer(tok);
505    if (tok.is(tok::r_paren)) {
506      Pass.TA.insert(tok.getLocation(), attr);
507      return true;
508    }
509  
510    if (tok.isNot(tok::raw_identifier)) return false;
511  
512    Pass.TA.insert(tok.getLocation(), std::string(attr) + ", ");
513    return true;
514  }
515  
traverse(TranslationUnitDecl * TU)516  void MigrationContext::traverse(TranslationUnitDecl *TU) {
517    for (traverser_iterator
518           I = traversers_begin(), E = traversers_end(); I != E; ++I)
519      (*I)->traverseTU(*this);
520  
521    ASTTransform(*this).TraverseDecl(TU);
522  }
523  
GCRewriteFinalize(MigrationPass & pass)524  static void GCRewriteFinalize(MigrationPass &pass) {
525    ASTContext &Ctx = pass.Ctx;
526    TransformActions &TA = pass.TA;
527    DeclContext *DC = Ctx.getTranslationUnitDecl();
528    Selector FinalizeSel =
529     Ctx.Selectors.getNullarySelector(&pass.Ctx.Idents.get("finalize"));
530  
531    typedef DeclContext::specific_decl_iterator<ObjCImplementationDecl>
532    impl_iterator;
533    for (impl_iterator I = impl_iterator(DC->decls_begin()),
534         E = impl_iterator(DC->decls_end()); I != E; ++I) {
535      for (ObjCImplementationDecl::instmeth_iterator
536           MI = I->instmeth_begin(),
537           ME = I->instmeth_end(); MI != ME; ++MI) {
538        ObjCMethodDecl *MD = *MI;
539        if (!MD->hasBody())
540          continue;
541  
542        if (MD->isInstanceMethod() && MD->getSelector() == FinalizeSel) {
543          ObjCMethodDecl *FinalizeM = MD;
544          Transaction Trans(TA);
545          TA.insert(FinalizeM->getSourceRange().getBegin(),
546                    "#if !__has_feature(objc_arc)\n");
547          CharSourceRange::getTokenRange(FinalizeM->getSourceRange());
548          const SourceManager &SM = pass.Ctx.getSourceManager();
549          const LangOptions &LangOpts = pass.Ctx.getLangOpts();
550          bool Invalid;
551          std::string str = "\n#endif\n";
552          str += Lexer::getSourceText(
553                    CharSourceRange::getTokenRange(FinalizeM->getSourceRange()),
554                                      SM, LangOpts, &Invalid);
555          TA.insertAfterToken(FinalizeM->getSourceRange().getEnd(), str);
556  
557          break;
558        }
559      }
560    }
561  }
562  
563  //===----------------------------------------------------------------------===//
564  // getAllTransformations.
565  //===----------------------------------------------------------------------===//
566  
traverseAST(MigrationPass & pass)567  static void traverseAST(MigrationPass &pass) {
568    MigrationContext MigrateCtx(pass);
569  
570    if (pass.isGCMigration()) {
571      MigrateCtx.addTraverser(new GCCollectableCallsTraverser);
572      MigrateCtx.addTraverser(new GCAttrsTraverser());
573    }
574    MigrateCtx.addTraverser(new PropertyRewriteTraverser());
575    MigrateCtx.addTraverser(new BlockObjCVariableTraverser());
576    MigrateCtx.addTraverser(new ProtectedScopeTraverser());
577  
578    MigrateCtx.traverse(pass.Ctx.getTranslationUnitDecl());
579  }
580  
independentTransforms(MigrationPass & pass)581  static void independentTransforms(MigrationPass &pass) {
582    rewriteAutoreleasePool(pass);
583    removeRetainReleaseDeallocFinalize(pass);
584    rewriteUnusedInitDelegate(pass);
585    removeZeroOutPropsInDeallocFinalize(pass);
586    makeAssignARCSafe(pass);
587    rewriteUnbridgedCasts(pass);
588    checkAPIUses(pass);
589    traverseAST(pass);
590  }
591  
getAllTransformations(LangOptions::GCMode OrigGCMode,bool NoFinalizeRemoval)592  std::vector<TransformFn> arcmt::getAllTransformations(
593                                                 LangOptions::GCMode OrigGCMode,
594                                                 bool NoFinalizeRemoval) {
595    std::vector<TransformFn> transforms;
596  
597    if (OrigGCMode ==  LangOptions::GCOnly && NoFinalizeRemoval)
598      transforms.push_back(GCRewriteFinalize);
599    transforms.push_back(independentTransforms);
600    // This depends on previous transformations removing various expressions.
601    transforms.push_back(removeEmptyStatementsAndDeallocFinalize);
602  
603    return transforms;
604  }
605