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