contrib/llvm/tools/clang/lib/Analysis/CocoaConventions.cpp

   1 //===- CocoaConventions.h - Special handling of Cocoa conventions -*- C++ -*--//
   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 // This file implements cocoa naming convention analysis.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "clang/Analysis/DomainSpecific/CocoaConventions.h"
  15 #include "clang/AST/Type.h"
  16 #include "clang/AST/Decl.h"
  17 #include "clang/AST/DeclObjC.h"
  18 #include "llvm/ADT/StringExtras.h"
  19 #include "llvm/Support/ErrorHandling.h"
  20
  21 using namespace clang;
  22 using namespace ento;
  23
  24 using llvm::StringRef;
  25
  26 // The "fundamental rule" for naming conventions of methods:
  27 //  (url broken into two lines)
  28 //  http://developer.apple.com/documentation/Cocoa/Conceptual/
  29 //     MemoryMgmt/Tasks/MemoryManagementRules.html
  30 //
  31 // "You take ownership of an object if you create it using a method whose name
  32 //  begins with "alloc" or "new" or contains "copy" (for example, alloc,
  33 //  newObject, or mutableCopy), or if you send it a retain message. You are
  34 //  responsible for relinquishing ownership of objects you own using release
  35 //  or autorelease. Any other time you receive an object, you must
  36 //  not release it."
  37 //
  38
  39 cocoa::NamingConvention cocoa::deriveNamingConvention(Selector S,
  40                                                     const ObjCMethodDecl *MD) {
  41   switch (MD && MD->hasAttr<ObjCMethodFamilyAttr>()? MD->getMethodFamily()
  42                                                    : S.getMethodFamily()) {
  43   case OMF_None:
  44   case OMF_autorelease:
  45   case OMF_dealloc:
  46   case OMF_release:
  47   case OMF_retain:
  48   case OMF_retainCount:
  49   case OMF_self:
  50   case OMF_performSelector:
  51     return NoConvention;
  52
  53   case OMF_init:
  54     return InitRule;
  55
  56   case OMF_alloc:
  57   case OMF_copy:
  58   case OMF_mutableCopy:
  59   case OMF_new:
  60     return CreateRule;
  61   }
  62   llvm_unreachable("unexpected naming convention");
  63   return NoConvention;
  64 }
  65
  66 bool cocoa::isRefType(QualType RetTy, llvm::StringRef Prefix,
  67                       llvm::StringRef Name) {
  68   // Recursively walk the typedef stack, allowing typedefs of reference types.
  69   while (const TypedefType *TD = dyn_cast<TypedefType>(RetTy.getTypePtr())) {
  70     llvm::StringRef TDName = TD->getDecl()->getIdentifier()->getName();
  71     if (TDName.startswith(Prefix) && TDName.endswith("Ref"))
  72       return true;
  73
  74     RetTy = TD->getDecl()->getUnderlyingType();
  75   }
  76
  77   if (Name.empty())
  78     return false;
  79
  80   // Is the type void*?
  81   const PointerType* PT = RetTy->getAs<PointerType>();
  82   if (!(PT->getPointeeType().getUnqualifiedType()->isVoidType()))
  83     return false;
  84
  85   // Does the name start with the prefix?
  86   return Name.startswith(Prefix);
  87 }
  88
  89 bool coreFoundation::isCFObjectRef(QualType T) {
  90   return cocoa::isRefType(T, "CF") || // Core Foundation.
  91          cocoa::isRefType(T, "CG") || // Core Graphics.
  92          cocoa::isRefType(T, "DADisk") || // Disk Arbitration API.
  93          cocoa::isRefType(T, "DADissenter") ||
  94          cocoa::isRefType(T, "DASessionRef");
  95 }
  96
  97
  98 bool cocoa::isCocoaObjectRef(QualType Ty) {
  99   if (!Ty->isObjCObjectPointerType())
 100     return false;
 101
 102   const ObjCObjectPointerType *PT = Ty->getAs<ObjCObjectPointerType>();
 103
 104   // Can be true for objects with the 'NSObject' attribute.
 105   if (!PT)
 106     return true;
 107
 108   // We assume that id<..>, id, Class, and Class<..> all represent tracked
 109   // objects.
 110   if (PT->isObjCIdType() || PT->isObjCQualifiedIdType() ||
 111       PT->isObjCClassType() || PT->isObjCQualifiedClassType())
 112     return true;
 113
 114   // Does the interface subclass NSObject?
 115   // FIXME: We can memoize here if this gets too expensive.
 116   const ObjCInterfaceDecl *ID = PT->getInterfaceDecl();
 117
 118   // Assume that anything declared with a forward declaration and no
 119   // @interface subclasses NSObject.
 120   if (ID->isForwardDecl())
 121     return true;
 122
 123   for ( ; ID ; ID = ID->getSuperClass())
 124     if (ID->getIdentifier()->getName() == "NSObject")
 125       return true;
 126
 127   return false;
 128 }
 129
 130 bool coreFoundation::followsCreateRule(llvm::StringRef functionName) {
 131   llvm::StringRef::iterator it = functionName.begin();
 132   llvm::StringRef::iterator start = it;
 133   llvm::StringRef::iterator endI = functionName.end();
 134
 135   while (true) {
 136     // Scan for the start of 'create' or 'copy'.
 137     for ( ; it != endI ; ++it) {
 138       // Search for the first character.  It can either be 'C' or 'c'.
 139       char ch = *it;
 140       if (ch == 'C' || ch == 'c') {
 141         ++it;
 142         break;
 143       }
 144     }
 145
 146     // Did we hit the end of the string?  If so, we didn't find a match.
 147     if (it == endI)
 148       return false;
 149
 150     // Scan for *lowercase* 'reate' or 'opy', followed by no lowercase
 151     // character.
 152     llvm::StringRef suffix = functionName.substr(it - start);
 153     if (suffix.startswith("reate")) {
 154       it += 5;
 155     }
 156     else if (suffix.startswith("opy")) {
 157       it += 3;
 158     }
 159     else {
 160       // Keep scanning.
 161       continue;
 162     }
 163
 164     if (it == endI || !islower(*it))
 165       return true;
 166
 167     // If we matched a lowercase character, it isn't the end of the
 168     // word.  Keep scanning.
 169   }
 170
 171   return false;
 172 }