CocoaConventions.cpp revision 797a7be0de6fbedaa85082b07ec9ce0674f30773
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 21using namespace clang; 22using namespace ento; 23 24using 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 39cocoa::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 66bool 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 89bool 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 98bool 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 130bool 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} 173