contrib/llvm/tools/clang/lib/ARCMigrate/TransGCAttrs.cpp

   1 //===--- TransGCAttrs.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/Lex/Lexer.h"
  13 #include "clang/Basic/SourceManager.h"
  14 #include "llvm/Support/SaveAndRestore.h"
  15 #include "clang/Sema/SemaDiagnostic.h"
  16 #include "llvm/ADT/SmallString.h"
  17 #include "llvm/ADT/TinyPtrVector.h"
  18
  19 using namespace clang;
  20 using namespace arcmt;
  21 using namespace trans;
  22
  23 namespace {
  24
  25 /// \brief Collects all the places where GC attributes __strong/__weak occur.
  26 class GCAttrsCollector : public RecursiveASTVisitor<GCAttrsCollector> {
  27   MigrationContext &MigrateCtx;
  28   bool FullyMigratable;
  29   std::vector<ObjCPropertyDecl *> &AllProps;
  30
  31   typedef RecursiveASTVisitor<GCAttrsCollector> base;
  32 public:
  33   GCAttrsCollector(MigrationContext &ctx,
  34                    std::vector<ObjCPropertyDecl *> &AllProps)
  35     : MigrateCtx(ctx), FullyMigratable(false),
  36       AllProps(AllProps) { }
  37
  38   bool shouldWalkTypesOfTypeLocs() const { return false; }
  39
  40   bool VisitAttributedTypeLoc(AttributedTypeLoc TL) {
  41     handleAttr(TL);
  42     return true;
  43   }
  44
  45   bool TraverseDecl(Decl *D) {
  46     if (!D || D->isImplicit())
  47       return true;
  48
  49     SaveAndRestore<bool> Save(FullyMigratable, isMigratable(D));
  50
  51     if (ObjCPropertyDecl *PropD = dyn_cast<ObjCPropertyDecl>(D)) {
  52       lookForAttribute(PropD, PropD->getTypeSourceInfo());
  53       AllProps.push_back(PropD);
  54     } else if (DeclaratorDecl *DD = dyn_cast<DeclaratorDecl>(D)) {
  55       lookForAttribute(DD, DD->getTypeSourceInfo());
  56     }
  57     return base::TraverseDecl(D);
  58   }
  59
  60   void lookForAttribute(Decl *D, TypeSourceInfo *TInfo) {
  61     if (!TInfo)
  62       return;
  63     TypeLoc TL = TInfo->getTypeLoc();
  64     while (TL) {
  65       if (const QualifiedTypeLoc *QL = dyn_cast<QualifiedTypeLoc>(&TL)) {
  66         TL = QL->getUnqualifiedLoc();
  67       } else if (const AttributedTypeLoc *
  68                    Attr = dyn_cast<AttributedTypeLoc>(&TL)) {
  69         if (handleAttr(*Attr, D))
  70           break;
  71         TL = Attr->getModifiedLoc();
  72       } else if (const ArrayTypeLoc *Arr = dyn_cast<ArrayTypeLoc>(&TL)) {
  73         TL = Arr->getElementLoc();
  74       } else if (const PointerTypeLoc *PT = dyn_cast<PointerTypeLoc>(&TL)) {
  75         TL = PT->getPointeeLoc();
  76       } else if (const ReferenceTypeLoc *RT = dyn_cast<ReferenceTypeLoc>(&TL))
  77         TL = RT->getPointeeLoc();
  78       else
  79         break;
  80     }
  81   }
  82
  83   bool handleAttr(AttributedTypeLoc TL, Decl *D = 0) {
  84     if (TL.getAttrKind() != AttributedType::attr_objc_ownership)
  85       return false;
  86
  87     SourceLocation Loc = TL.getAttrNameLoc();
  88     unsigned RawLoc = Loc.getRawEncoding();
  89     if (MigrateCtx.AttrSet.count(RawLoc))
  90       return true;
  91
  92     ASTContext &Ctx = MigrateCtx.Pass.Ctx;
  93     SourceManager &SM = Ctx.getSourceManager();
  94     if (Loc.isMacroID())
  95       Loc = SM.getImmediateExpansionRange(Loc).first;
  96     SmallString<32> Buf;
  97     bool Invalid = false;
  98     StringRef Spell = Lexer::getSpelling(
  99                                   SM.getSpellingLoc(TL.getAttrEnumOperandLoc()),
 100                                   Buf, SM, Ctx.getLangOpts(), &Invalid);
 101     if (Invalid)
 102       return false;
 103     MigrationContext::GCAttrOccurrence::AttrKind Kind;
 104     if (Spell == "strong")
 105       Kind = MigrationContext::GCAttrOccurrence::Strong;
 106     else if (Spell == "weak")
 107       Kind = MigrationContext::GCAttrOccurrence::Weak;
 108     else
 109       return false;
 110
 111     MigrateCtx.AttrSet.insert(RawLoc);
 112     MigrateCtx.GCAttrs.push_back(MigrationContext::GCAttrOccurrence());
 113     MigrationContext::GCAttrOccurrence &Attr = MigrateCtx.GCAttrs.back();
 114
 115     Attr.Kind = Kind;
 116     Attr.Loc = Loc;
 117     Attr.ModifiedType = TL.getModifiedLoc().getType();
 118     Attr.Dcl = D;
 119     Attr.FullyMigratable = FullyMigratable;
 120     return true;
 121   }
 122
 123   bool isMigratable(Decl *D) {
 124     if (isa<TranslationUnitDecl>(D))
 125       return false;
 126
 127     if (isInMainFile(D))
 128       return true;
 129
 130     if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D))
 131       return FD->hasBody();
 132
 133     if (ObjCContainerDecl *ContD = dyn_cast<ObjCContainerDecl>(D))
 134       return hasObjCImpl(ContD);
 135
 136     if (CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(D)) {
 137       for (CXXRecordDecl::method_iterator
 138              MI = RD->method_begin(), ME = RD->method_end(); MI != ME; ++MI) {
 139         if ((*MI)->isOutOfLine())
 140           return true;
 141       }
 142       return false;
 143     }
 144
 145     return isMigratable(cast<Decl>(D->getDeclContext()));
 146   }
 147
 148   static bool hasObjCImpl(Decl *D) {
 149     if (!D)
 150       return false;
 151     if (ObjCContainerDecl *ContD = dyn_cast<ObjCContainerDecl>(D)) {
 152       if (ObjCInterfaceDecl *ID = dyn_cast<ObjCInterfaceDecl>(ContD))
 153         return ID->getImplementation() != 0;
 154       if (ObjCCategoryDecl *CD = dyn_cast<ObjCCategoryDecl>(ContD))
 155         return CD->getImplementation() != 0;
 156       if (isa<ObjCImplDecl>(ContD))
 157         return true;
 158       return false;
 159     }
 160     return false;
 161   }
 162
 163   bool isInMainFile(Decl *D) {
 164     if (!D)
 165       return false;
 166
 167     for (Decl::redecl_iterator
 168            I = D->redecls_begin(), E = D->redecls_end(); I != E; ++I)
 169       if (!isInMainFile((*I)->getLocation()))
 170         return false;
 171
 172     return true;
 173   }
 174
 175   bool isInMainFile(SourceLocation Loc) {
 176     if (Loc.isInvalid())
 177       return false;
 178
 179     SourceManager &SM = MigrateCtx.Pass.Ctx.getSourceManager();
 180     return SM.isInFileID(SM.getExpansionLoc(Loc), SM.getMainFileID());
 181   }
 182 };
 183
 184 } // anonymous namespace
 185
 186 static void errorForGCAttrsOnNonObjC(MigrationContext &MigrateCtx) {
 187   TransformActions &TA = MigrateCtx.Pass.TA;
 188
 189   for (unsigned i = 0, e = MigrateCtx.GCAttrs.size(); i != e; ++i) {
 190     MigrationContext::GCAttrOccurrence &Attr = MigrateCtx.GCAttrs[i];
 191     if (Attr.FullyMigratable && Attr.Dcl) {
 192       if (Attr.ModifiedType.isNull())
 193         continue;
 194       if (!Attr.ModifiedType->isObjCRetainableType()) {
 195         TA.reportError("GC managed memory will become unmanaged in ARC",
 196                        Attr.Loc);
 197       }
 198     }
 199   }
 200 }
 201
 202 static void checkWeakGCAttrs(MigrationContext &MigrateCtx) {
 203   TransformActions &TA = MigrateCtx.Pass.TA;
 204
 205   for (unsigned i = 0, e = MigrateCtx.GCAttrs.size(); i != e; ++i) {
 206     MigrationContext::GCAttrOccurrence &Attr = MigrateCtx.GCAttrs[i];
 207     if (Attr.Kind == MigrationContext::GCAttrOccurrence::Weak) {
 208       if (Attr.ModifiedType.isNull() ||
 209           !Attr.ModifiedType->isObjCRetainableType())
 210         continue;
 211       if (!canApplyWeak(MigrateCtx.Pass.Ctx, Attr.ModifiedType,
 212                         /*AllowOnUnknownClass=*/true)) {
 213         Transaction Trans(TA);
 214         if (!MigrateCtx.RemovedAttrSet.count(Attr.Loc.getRawEncoding()))
 215           TA.replaceText(Attr.Loc, "__weak", "__unsafe_unretained");
 216         TA.clearDiagnostic(diag::err_arc_weak_no_runtime,
 217                            diag::err_arc_unsupported_weak_class,
 218                            Attr.Loc);
 219       }
 220     }
 221   }
 222 }
 223
 224 typedef llvm::TinyPtrVector<ObjCPropertyDecl *> IndivPropsTy;
 225
 226 static void checkAllAtProps(MigrationContext &MigrateCtx,
 227                             SourceLocation AtLoc,
 228                             IndivPropsTy &IndProps) {
 229   if (IndProps.empty())
 230     return;
 231
 232   for (IndivPropsTy::iterator
 233          PI = IndProps.begin(), PE = IndProps.end(); PI != PE; ++PI) {
 234     QualType T = (*PI)->getType();
 235     if (T.isNull() || !T->isObjCRetainableType())
 236       return;
 237   }
 238
 239   SmallVector<std::pair<AttributedTypeLoc, ObjCPropertyDecl *>, 4> ATLs;
 240   bool hasWeak = false, hasStrong = false;
 241   ObjCPropertyDecl::PropertyAttributeKind
 242     Attrs = ObjCPropertyDecl::OBJC_PR_noattr;
 243   for (IndivPropsTy::iterator
 244          PI = IndProps.begin(), PE = IndProps.end(); PI != PE; ++PI) {
 245     ObjCPropertyDecl *PD = *PI;
 246     Attrs = PD->getPropertyAttributesAsWritten();
 247     TypeSourceInfo *TInfo = PD->getTypeSourceInfo();
 248     if (!TInfo)
 249       return;
 250     TypeLoc TL = TInfo->getTypeLoc();
 251     if (AttributedTypeLoc *ATL = dyn_cast<AttributedTypeLoc>(&TL)) {
 252       ATLs.push_back(std::make_pair(*ATL, PD));
 253       if (TInfo->getType().getObjCLifetime() == Qualifiers::OCL_Weak) {
 254         hasWeak = true;
 255       } else if (TInfo->getType().getObjCLifetime() == Qualifiers::OCL_Strong)
 256         hasStrong = true;
 257       else
 258         return;
 259     }
 260   }
 261   if (ATLs.empty())
 262     return;
 263   if (hasWeak && hasStrong)
 264     return;
 265
 266   TransformActions &TA = MigrateCtx.Pass.TA;
 267   Transaction Trans(TA);
 268
 269   if (GCAttrsCollector::hasObjCImpl(
 270                               cast<Decl>(IndProps.front()->getDeclContext()))) {
 271     if (hasWeak)
 272       MigrateCtx.AtPropsWeak.insert(AtLoc.getRawEncoding());
 273
 274   } else {
 275     StringRef toAttr = "strong";
 276     if (hasWeak) {
 277       if (canApplyWeak(MigrateCtx.Pass.Ctx, IndProps.front()->getType(),
 278                        /*AllowOnUnkwownClass=*/true))
 279         toAttr = "weak";
 280       else
 281         toAttr = "unsafe_unretained";
 282     }
 283     if (Attrs & ObjCPropertyDecl::OBJC_PR_assign)
 284       MigrateCtx.rewritePropertyAttribute("assign", toAttr, AtLoc);
 285     else
 286       MigrateCtx.addPropertyAttribute(toAttr, AtLoc);
 287   }
 288
 289   for (unsigned i = 0, e = ATLs.size(); i != e; ++i) {
 290     SourceLocation Loc = ATLs[i].first.getAttrNameLoc();
 291     if (Loc.isMacroID())
 292       Loc = MigrateCtx.Pass.Ctx.getSourceManager()
 293                                          .getImmediateExpansionRange(Loc).first;
 294     TA.remove(Loc);
 295     TA.clearDiagnostic(diag::err_objc_property_attr_mutually_exclusive, AtLoc);
 296     TA.clearDiagnostic(diag::err_arc_inconsistent_property_ownership,
 297                        ATLs[i].second->getLocation());
 298     MigrateCtx.RemovedAttrSet.insert(Loc.getRawEncoding());
 299   }
 300 }
 301
 302 static void checkAllProps(MigrationContext &MigrateCtx,
 303                           std::vector<ObjCPropertyDecl *> &AllProps) {
 304   typedef llvm::TinyPtrVector<ObjCPropertyDecl *> IndivPropsTy;
 305   llvm::DenseMap<unsigned, IndivPropsTy> AtProps;
 306
 307   for (unsigned i = 0, e = AllProps.size(); i != e; ++i) {
 308     ObjCPropertyDecl *PD = AllProps[i];
 309     if (PD->getPropertyAttributesAsWritten() &
 310           (ObjCPropertyDecl::OBJC_PR_assign |
 311            ObjCPropertyDecl::OBJC_PR_readonly)) {
 312       SourceLocation AtLoc = PD->getAtLoc();
 313       if (AtLoc.isInvalid())
 314         continue;
 315       unsigned RawAt = AtLoc.getRawEncoding();
 316       AtProps[RawAt].push_back(PD);
 317     }
 318   }
 319
 320   for (llvm::DenseMap<unsigned, IndivPropsTy>::iterator
 321          I = AtProps.begin(), E = AtProps.end(); I != E; ++I) {
 322     SourceLocation AtLoc = SourceLocation::getFromRawEncoding(I->first);
 323     IndivPropsTy &IndProps = I->second;
 324     checkAllAtProps(MigrateCtx, AtLoc, IndProps);
 325   }
 326 }
 327
 328 void GCAttrsTraverser::traverseTU(MigrationContext &MigrateCtx) {
 329   std::vector<ObjCPropertyDecl *> AllProps;
 330   GCAttrsCollector(MigrateCtx, AllProps).TraverseDecl(
 331                                   MigrateCtx.Pass.Ctx.getTranslationUnitDecl());
 332
 333   errorForGCAttrsOnNonObjC(MigrateCtx);
 334   checkAllProps(MigrateCtx, AllProps);
 335   checkWeakGCAttrs(MigrateCtx);
 336 }
 337
 338 void MigrationContext::dumpGCAttrs() {
 339   llvm::errs() << "\n################\n";
 340   for (unsigned i = 0, e = GCAttrs.size(); i != e; ++i) {
 341     GCAttrOccurrence &Attr = GCAttrs[i];
 342     llvm::errs() << "KIND: "
 343         << (Attr.Kind == GCAttrOccurrence::Strong ? "strong" : "weak");
 344     llvm::errs() << "\nLOC: ";
 345     Attr.Loc.dump(Pass.Ctx.getSourceManager());
 346     llvm::errs() << "\nTYPE: ";
 347     Attr.ModifiedType.dump();
 348     if (Attr.Dcl) {
 349       llvm::errs() << "DECL:\n";
 350       Attr.Dcl->dump();
 351     } else {
 352       llvm::errs() << "DECL: NONE";
 353     }
 354     llvm::errs() << "\nMIGRATABLE: " << Attr.FullyMigratable;
 355     llvm::errs() << "\n----------------\n";
 356   }
 357   llvm::errs() << "\n################\n";
 358 }