1 //===--- TransProperties.cpp - Transformations to ARC mode ----------------===//
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 // rewriteProperties:
10 //
11 // - Adds strong/weak/unsafe_unretained ownership specifier to properties that
12 //   are missing one.
13 // - Migrates properties from (retain) to (strong) and (assign) to
14 //   (unsafe_unretained/weak).
15 // - If a property is synthesized, adds the ownership specifier in the ivar
16 //   backing the property.
17 //
18 //  @interface Foo : NSObject {
19 //      NSObject *x;
20 //  }
21 //  @property (assign) id x;
22 //  @end
23 // ---->
24 //  @interface Foo : NSObject {
25 //      NSObject *__weak x;
26 //  }
27 //  @property (weak) id x;
28 //  @end
29 //
30 //===----------------------------------------------------------------------===//
31 
32 #include "Transforms.h"
33 #include "Internals.h"
34 #include "clang/Basic/SourceManager.h"
35 #include "clang/Lex/Lexer.h"
36 #include "clang/Sema/SemaDiagnostic.h"
37 #include <map>
38 
39 using namespace clang;
40 using namespace arcmt;
41 using namespace trans;
42 
43 namespace {
44 
45 class PropertiesRewriter {
46   MigrationContext &MigrateCtx;
47   MigrationPass &Pass;
48   ObjCImplementationDecl *CurImplD;
49 
50   enum PropActionKind {
51     PropAction_None,
52     PropAction_RetainReplacedWithStrong,
53     PropAction_AssignRemoved,
54     PropAction_AssignRewritten,
55     PropAction_MaybeAddWeakOrUnsafe
56   };
57 
58   struct PropData {
59     ObjCPropertyDecl *PropD;
60     ObjCIvarDecl *IvarD;
61     ObjCPropertyImplDecl *ImplD;
62 
PropData__anon8c05bc340111::PropertiesRewriter::PropData63     PropData(ObjCPropertyDecl *propD)
64       : PropD(propD), IvarD(nullptr), ImplD(nullptr) {}
65   };
66 
67   typedef SmallVector<PropData, 2> PropsTy;
68   typedef std::map<SourceLocation, PropsTy> AtPropDeclsTy;
69   AtPropDeclsTy AtProps;
70   llvm::DenseMap<IdentifierInfo *, PropActionKind> ActionOnProp;
71 
72 public:
PropertiesRewriter(MigrationContext & MigrateCtx)73   explicit PropertiesRewriter(MigrationContext &MigrateCtx)
74     : MigrateCtx(MigrateCtx), Pass(MigrateCtx.Pass) { }
75 
collectProperties(ObjCContainerDecl * D,AtPropDeclsTy & AtProps,AtPropDeclsTy * PrevAtProps=nullptr)76   static void collectProperties(ObjCContainerDecl *D, AtPropDeclsTy &AtProps,
77                                 AtPropDeclsTy *PrevAtProps = nullptr) {
78     for (auto *Prop : D->instance_properties()) {
79       SourceLocation Loc = Prop->getAtLoc();
80       if (Loc.isInvalid())
81         continue;
82       if (PrevAtProps)
83         if (PrevAtProps->find(Loc) != PrevAtProps->end())
84           continue;
85       PropsTy &props = AtProps[Loc];
86       props.push_back(Prop);
87     }
88   }
89 
doTransform(ObjCImplementationDecl * D)90   void doTransform(ObjCImplementationDecl *D) {
91     CurImplD = D;
92     ObjCInterfaceDecl *iface = D->getClassInterface();
93     if (!iface)
94       return;
95 
96     collectProperties(iface, AtProps);
97 
98     // Look through extensions.
99     for (auto *Ext : iface->visible_extensions())
100       collectProperties(Ext, AtProps);
101 
102     typedef DeclContext::specific_decl_iterator<ObjCPropertyImplDecl>
103         prop_impl_iterator;
104     for (prop_impl_iterator
105            I = prop_impl_iterator(D->decls_begin()),
106            E = prop_impl_iterator(D->decls_end()); I != E; ++I) {
107       ObjCPropertyImplDecl *implD = *I;
108       if (implD->getPropertyImplementation() != ObjCPropertyImplDecl::Synthesize)
109         continue;
110       ObjCPropertyDecl *propD = implD->getPropertyDecl();
111       if (!propD || propD->isInvalidDecl())
112         continue;
113       ObjCIvarDecl *ivarD = implD->getPropertyIvarDecl();
114       if (!ivarD || ivarD->isInvalidDecl())
115         continue;
116       AtPropDeclsTy::iterator findAtLoc = AtProps.find(propD->getAtLoc());
117       if (findAtLoc == AtProps.end())
118         continue;
119 
120       PropsTy &props = findAtLoc->second;
121       for (PropsTy::iterator I = props.begin(), E = props.end(); I != E; ++I) {
122         if (I->PropD == propD) {
123           I->IvarD = ivarD;
124           I->ImplD = implD;
125           break;
126         }
127       }
128     }
129 
130     for (AtPropDeclsTy::iterator
131            I = AtProps.begin(), E = AtProps.end(); I != E; ++I) {
132       SourceLocation atLoc = I->first;
133       PropsTy &props = I->second;
134       if (!getPropertyType(props)->isObjCRetainableType())
135         continue;
136       if (hasIvarWithExplicitARCOwnership(props))
137         continue;
138 
139       Transaction Trans(Pass.TA);
140       rewriteProperty(props, atLoc);
141     }
142   }
143 
144 private:
doPropAction(PropActionKind kind,PropsTy & props,SourceLocation atLoc,bool markAction=true)145   void doPropAction(PropActionKind kind,
146                     PropsTy &props, SourceLocation atLoc,
147                     bool markAction = true) {
148     if (markAction)
149       for (PropsTy::iterator I = props.begin(), E = props.end(); I != E; ++I)
150         ActionOnProp[I->PropD->getIdentifier()] = kind;
151 
152     switch (kind) {
153     case PropAction_None:
154       return;
155     case PropAction_RetainReplacedWithStrong: {
156       StringRef toAttr = "strong";
157       MigrateCtx.rewritePropertyAttribute("retain", toAttr, atLoc);
158       return;
159     }
160     case PropAction_AssignRemoved:
161       return removeAssignForDefaultStrong(props, atLoc);
162     case PropAction_AssignRewritten:
163       return rewriteAssign(props, atLoc);
164     case PropAction_MaybeAddWeakOrUnsafe:
165       return maybeAddWeakOrUnsafeUnretainedAttr(props, atLoc);
166     }
167   }
168 
rewriteProperty(PropsTy & props,SourceLocation atLoc)169   void rewriteProperty(PropsTy &props, SourceLocation atLoc) {
170     ObjCPropertyAttribute::Kind propAttrs = getPropertyAttrs(props);
171 
172     if (propAttrs &
173         (ObjCPropertyAttribute::kind_copy |
174          ObjCPropertyAttribute::kind_unsafe_unretained |
175          ObjCPropertyAttribute::kind_strong | ObjCPropertyAttribute::kind_weak))
176       return;
177 
178     if (propAttrs & ObjCPropertyAttribute::kind_retain) {
179       // strong is the default.
180       return doPropAction(PropAction_RetainReplacedWithStrong, props, atLoc);
181     }
182 
183     bool HasIvarAssignedAPlusOneObject = hasIvarAssignedAPlusOneObject(props);
184 
185     if (propAttrs & ObjCPropertyAttribute::kind_assign) {
186       if (HasIvarAssignedAPlusOneObject)
187         return doPropAction(PropAction_AssignRemoved, props, atLoc);
188       return doPropAction(PropAction_AssignRewritten, props, atLoc);
189     }
190 
191     if (HasIvarAssignedAPlusOneObject ||
192         (Pass.isGCMigration() && !hasGCWeak(props, atLoc)))
193       return; // 'strong' by default.
194 
195     return doPropAction(PropAction_MaybeAddWeakOrUnsafe, props, atLoc);
196   }
197 
removeAssignForDefaultStrong(PropsTy & props,SourceLocation atLoc) const198   void removeAssignForDefaultStrong(PropsTy &props,
199                                     SourceLocation atLoc) const {
200     removeAttribute("retain", atLoc);
201     if (!removeAttribute("assign", atLoc))
202       return;
203 
204     for (PropsTy::iterator I = props.begin(), E = props.end(); I != E; ++I) {
205       if (I->ImplD)
206         Pass.TA.clearDiagnostic(diag::err_arc_strong_property_ownership,
207                                 diag::err_arc_assign_property_ownership,
208                                 diag::err_arc_inconsistent_property_ownership,
209                                 I->IvarD->getLocation());
210     }
211   }
212 
rewriteAssign(PropsTy & props,SourceLocation atLoc) const213   void rewriteAssign(PropsTy &props, SourceLocation atLoc) const {
214     bool canUseWeak = canApplyWeak(Pass.Ctx, getPropertyType(props),
215                                   /*AllowOnUnknownClass=*/Pass.isGCMigration());
216     const char *toWhich =
217       (Pass.isGCMigration() && !hasGCWeak(props, atLoc)) ? "strong" :
218       (canUseWeak ? "weak" : "unsafe_unretained");
219 
220     bool rewroteAttr = rewriteAttribute("assign", toWhich, atLoc);
221     if (!rewroteAttr)
222       canUseWeak = false;
223 
224     for (PropsTy::iterator I = props.begin(), E = props.end(); I != E; ++I) {
225       if (isUserDeclared(I->IvarD)) {
226         if (I->IvarD &&
227             I->IvarD->getType().getObjCLifetime() != Qualifiers::OCL_Weak) {
228           const char *toWhich =
229             (Pass.isGCMigration() && !hasGCWeak(props, atLoc)) ? "__strong " :
230               (canUseWeak ? "__weak " : "__unsafe_unretained ");
231           Pass.TA.insert(I->IvarD->getLocation(), toWhich);
232         }
233       }
234       if (I->ImplD)
235         Pass.TA.clearDiagnostic(diag::err_arc_strong_property_ownership,
236                                 diag::err_arc_assign_property_ownership,
237                                 diag::err_arc_inconsistent_property_ownership,
238                                 I->IvarD->getLocation());
239     }
240   }
241 
maybeAddWeakOrUnsafeUnretainedAttr(PropsTy & props,SourceLocation atLoc) const242   void maybeAddWeakOrUnsafeUnretainedAttr(PropsTy &props,
243                                           SourceLocation atLoc) const {
244     bool canUseWeak = canApplyWeak(Pass.Ctx, getPropertyType(props),
245                                   /*AllowOnUnknownClass=*/Pass.isGCMigration());
246 
247     bool addedAttr = addAttribute(canUseWeak ? "weak" : "unsafe_unretained",
248                                   atLoc);
249     if (!addedAttr)
250       canUseWeak = false;
251 
252     for (PropsTy::iterator I = props.begin(), E = props.end(); I != E; ++I) {
253       if (isUserDeclared(I->IvarD)) {
254         if (I->IvarD &&
255             I->IvarD->getType().getObjCLifetime() != Qualifiers::OCL_Weak)
256           Pass.TA.insert(I->IvarD->getLocation(),
257                          canUseWeak ? "__weak " : "__unsafe_unretained ");
258       }
259       if (I->ImplD) {
260         Pass.TA.clearDiagnostic(diag::err_arc_strong_property_ownership,
261                                 diag::err_arc_assign_property_ownership,
262                                 diag::err_arc_inconsistent_property_ownership,
263                                 I->IvarD->getLocation());
264         Pass.TA.clearDiagnostic(
265                            diag::err_arc_objc_property_default_assign_on_object,
266                            I->ImplD->getLocation());
267       }
268     }
269   }
270 
removeAttribute(StringRef fromAttr,SourceLocation atLoc) const271   bool removeAttribute(StringRef fromAttr, SourceLocation atLoc) const {
272     return MigrateCtx.removePropertyAttribute(fromAttr, atLoc);
273   }
274 
rewriteAttribute(StringRef fromAttr,StringRef toAttr,SourceLocation atLoc) const275   bool rewriteAttribute(StringRef fromAttr, StringRef toAttr,
276                         SourceLocation atLoc) const {
277     return MigrateCtx.rewritePropertyAttribute(fromAttr, toAttr, atLoc);
278   }
279 
addAttribute(StringRef attr,SourceLocation atLoc) const280   bool addAttribute(StringRef attr, SourceLocation atLoc) const {
281     return MigrateCtx.addPropertyAttribute(attr, atLoc);
282   }
283 
284   class PlusOneAssign : public RecursiveASTVisitor<PlusOneAssign> {
285     ObjCIvarDecl *Ivar;
286   public:
PlusOneAssign(ObjCIvarDecl * D)287     PlusOneAssign(ObjCIvarDecl *D) : Ivar(D) {}
288 
VisitBinaryOperator(BinaryOperator * E)289     bool VisitBinaryOperator(BinaryOperator *E) {
290       if (E->getOpcode() != BO_Assign)
291         return true;
292 
293       Expr *lhs = E->getLHS()->IgnoreParenImpCasts();
294       if (ObjCIvarRefExpr *RE = dyn_cast<ObjCIvarRefExpr>(lhs)) {
295         if (RE->getDecl() != Ivar)
296           return true;
297 
298         if (isPlusOneAssign(E))
299           return false;
300       }
301 
302       return true;
303     }
304   };
305 
hasIvarAssignedAPlusOneObject(PropsTy & props) const306   bool hasIvarAssignedAPlusOneObject(PropsTy &props) const {
307     for (PropsTy::iterator I = props.begin(), E = props.end(); I != E; ++I) {
308       PlusOneAssign oneAssign(I->IvarD);
309       bool notFound = oneAssign.TraverseDecl(CurImplD);
310       if (!notFound)
311         return true;
312     }
313 
314     return false;
315   }
316 
hasIvarWithExplicitARCOwnership(PropsTy & props) const317   bool hasIvarWithExplicitARCOwnership(PropsTy &props) const {
318     if (Pass.isGCMigration())
319       return false;
320 
321     for (PropsTy::iterator I = props.begin(), E = props.end(); I != E; ++I) {
322       if (isUserDeclared(I->IvarD)) {
323         if (isa<AttributedType>(I->IvarD->getType()))
324           return true;
325         if (I->IvarD->getType().getLocalQualifiers().getObjCLifetime()
326               != Qualifiers::OCL_Strong)
327           return true;
328       }
329     }
330 
331     return false;
332   }
333 
334   // Returns true if all declarations in the @property have GC __weak.
hasGCWeak(PropsTy & props,SourceLocation atLoc) const335   bool hasGCWeak(PropsTy &props, SourceLocation atLoc) const {
336     if (!Pass.isGCMigration())
337       return false;
338     if (props.empty())
339       return false;
340     return MigrateCtx.AtPropsWeak.count(atLoc);
341   }
342 
isUserDeclared(ObjCIvarDecl * ivarD) const343   bool isUserDeclared(ObjCIvarDecl *ivarD) const {
344     return ivarD && !ivarD->getSynthesize();
345   }
346 
getPropertyType(PropsTy & props) const347   QualType getPropertyType(PropsTy &props) const {
348     assert(!props.empty());
349     QualType ty = props[0].PropD->getType().getUnqualifiedType();
350 
351 #ifndef NDEBUG
352     for (PropsTy::iterator I = props.begin(), E = props.end(); I != E; ++I)
353       assert(ty == I->PropD->getType().getUnqualifiedType());
354 #endif
355 
356     return ty;
357   }
358 
getPropertyAttrs(PropsTy & props) const359   ObjCPropertyAttribute::Kind getPropertyAttrs(PropsTy &props) const {
360     assert(!props.empty());
361     ObjCPropertyAttribute::Kind attrs =
362         props[0].PropD->getPropertyAttributesAsWritten();
363 
364 #ifndef NDEBUG
365     for (PropsTy::iterator I = props.begin(), E = props.end(); I != E; ++I)
366       assert(attrs == I->PropD->getPropertyAttributesAsWritten());
367 #endif
368 
369     return attrs;
370   }
371 };
372 
373 } // anonymous namespace
374 
traverseObjCImplementation(ObjCImplementationContext & ImplCtx)375 void PropertyRewriteTraverser::traverseObjCImplementation(
376                                            ObjCImplementationContext &ImplCtx) {
377   PropertiesRewriter(ImplCtx.getMigrationContext())
378                                   .doTransform(ImplCtx.getImplementationDecl());
379 }
380