CocoaConventions.cpp revision 221345
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 defines 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 switch (S.getMethodFamily()) { 41 case OMF_None: 42 case OMF_autorelease: 43 case OMF_dealloc: 44 case OMF_release: 45 case OMF_retain: 46 case OMF_retainCount: 47 return NoConvention; 48 49 case OMF_init: 50 return InitRule; 51 52 case OMF_alloc: 53 case OMF_copy: 54 case OMF_mutableCopy: 55 case OMF_new: 56 return CreateRule; 57 } 58 llvm_unreachable("unexpected naming convention"); 59 return NoConvention; 60} 61 62bool cocoa::isRefType(QualType RetTy, llvm::StringRef Prefix, 63 llvm::StringRef Name) { 64 // Recursively walk the typedef stack, allowing typedefs of reference types. 65 while (const TypedefType *TD = dyn_cast<TypedefType>(RetTy.getTypePtr())) { 66 llvm::StringRef TDName = TD->getDecl()->getIdentifier()->getName(); 67 if (TDName.startswith(Prefix) && TDName.endswith("Ref")) 68 return true; 69 70 RetTy = TD->getDecl()->getUnderlyingType(); 71 } 72 73 if (Name.empty()) 74 return false; 75 76 // Is the type void*? 77 const PointerType* PT = RetTy->getAs<PointerType>(); 78 if (!(PT->getPointeeType().getUnqualifiedType()->isVoidType())) 79 return false; 80 81 // Does the name start with the prefix? 82 return Name.startswith(Prefix); 83} 84 85bool cocoa::isCFObjectRef(QualType T) { 86 return isRefType(T, "CF") || // Core Foundation. 87 isRefType(T, "CG") || // Core Graphics. 88 isRefType(T, "DADisk") || // Disk Arbitration API. 89 isRefType(T, "DADissenter") || 90 isRefType(T, "DASessionRef"); 91} 92 93 94bool cocoa::isCocoaObjectRef(QualType Ty) { 95 if (!Ty->isObjCObjectPointerType()) 96 return false; 97 98 const ObjCObjectPointerType *PT = Ty->getAs<ObjCObjectPointerType>(); 99 100 // Can be true for objects with the 'NSObject' attribute. 101 if (!PT) 102 return true; 103 104 // We assume that id<..>, id, Class, and Class<..> all represent tracked 105 // objects. 106 if (PT->isObjCIdType() || PT->isObjCQualifiedIdType() || 107 PT->isObjCClassType() || PT->isObjCQualifiedClassType()) 108 return true; 109 110 // Does the interface subclass NSObject? 111 // FIXME: We can memoize here if this gets too expensive. 112 const ObjCInterfaceDecl *ID = PT->getInterfaceDecl(); 113 114 // Assume that anything declared with a forward declaration and no 115 // @interface subclasses NSObject. 116 if (ID->isForwardDecl()) 117 return true; 118 119 for ( ; ID ; ID = ID->getSuperClass()) 120 if (ID->getIdentifier()->getName() == "NSObject") 121 return true; 122 123 return false; 124} 125