CODEWITHSUNDEEP
objective-cvariablesios5propertiesautomatic-ref-counting
Noam
Noam

Reputation: 3140

Semantic Issue: Property's synthesized getter follows Cocoa naming convention for returning 'owned' objects

I'm currently using the iOS 5 SDK trying to develop my app. I'm trying to make an NSString a property, and then to synthesize it in the .m file (I have done this before with no issues). Now, I came across this: "Semantic Issue: Property's synthesized getter follows Cocoa naming convention for returning 'owned' objects."

This is my code: .h

@interface ViewController : UIViewController {
     NSString *newTitle;
}
@property (strong, nonatomic) NSString *newTitle;

.m

@synthesize newTitle;

Does anyone have a clue how I could fix this? Thanks!!

Upvotes: 293

Views: 82023

Answers (10)

DawnSong
DawnSong

Reputation: 5162

NS_RETURNS_NOT_RETAINED is used to solve the naming problem.

@property (nonatomic, copy) NSString *newTitle NS_RETURNS_NOT_RETAINED;

We can find its definition as follows:

#define NS_RETURNS_NOT_RETAINED __attribute__((ns_returns_not_retained))

The 'ns_returns_not_retained' attribute is the complement of 'ns_returns_retained'. Where a function or method may appear to obey the Cocoa conventions and return a retained Cocoa object, this attribute can be used to indicate that the object reference returned should not be considered as an "owning" reference being returned to the caller. The Foundation framework defines a macro NS_RETURNS_NOT_RETAINED that is functionally equivalent to the one shown below.

Upvotes: 2

user557219
user557219

Reputation:

My guess is that the compiler version you’re using follows the memory management rules for declared properties, too — more specifically, for declared properties’ accessors:

You take ownership of an object if you create it using a method whose name begins with “alloc”, “new”, “copy”, or “mutableCopy”.

A property named newTitle, when synthesised, yields a method called -newTitle, hence the warning/error. -newTitle is supposed to be a getter method for the newTitle property, however naming conventions state that a method whose name begins with new returns an object that’s owned by the caller, which is not the case of getter methods.

You can solve this by:

  1. Renaming that property:

    @property (strong, nonatomic) NSString *theNewTitle;

  2. Keeping the property name and specifying a getter name that doesn’t begin with one of the special method name prefixes:

    @property (strong, nonatomic, getter=theNewTitle) NSString *newTitle;

  3. Keeping both the property name and the getter name, and telling the compiler that, even though the getter name starts with new, it belongs to the none method family as opposed to the new method family:

    #ifndef __has_attribute
#define __has_attribute(x) 0  // Compatibility with non-clang compilers
#endif

#if __has_attribute(objc_method_family)
#define BV_OBJC_METHOD_FAMILY_NONE __attribute__((objc_method_family(none)))
#else
#define BV_OBJC_METHOD_FAMILY_NONE
#endif

@interface ViewController : UIViewController
@property (strong, nonatomic) NSString *newTitle;
- (NSString *)newTitle BV_OBJC_METHOD_FAMILY_NONE;
@end

    Note that even though this solution allows you to keep newTitle as both the property name and the getter name, having a method called -newTitle that doesn’t return an object owned by the caller can be confusing for other people reading your code.

For the record, Apple have published Transitioning to ARC Release Notes, in which they state:

You cannot give a property a name that begins with new or copy.

They’ve already been notified that their statement is not quite accurate: the culprit is the getter method name, not the property name.

Edit 17 Jan 2015: I’ve just noticed a recent commit to Clang that suggests option 3 above (using objc_method_family(none)), including a fix-it, for the general case where a property name matches one of the special method family prefixes. Xcode will likely incorporate this change eventually.

Upvotes: 623

Jacksonkr
Jacksonkr

Reputation: 32207

Unacceptable Object Names

  • newButton
  • copyLabel
  • allocTitle

Acceptable Object Names

  • neueButton
  • mCopyLabel
  • _allocTitle

#arc #auto-synthesized #xcode-4.6.1

** EDIT **

Apparently you can't use mutableCopy either.

Upvotes: 59

Philipp Schaller
Philipp Schaller

Reputation: 367

Besides the issue that you should/can't use "new" in front of you property names, let say one more thing: Try to avoid "new" in front of names in general. "New" is dependent on time. Currently it is new for you, but some time later you maybe want to implement something new again. So using "new" in names is always bad. Try to think this way: In the programming world, "new" is always creating something: a new instance of something.

In your case when you want to assign a different title then the current name your property titleReplacement.

One more thing: Try to name functions and methods with the verb first, like setSomething or getSomething. But in properties try to name the object first, like heightMinimum, heightMaximum, etc. -> when you use your inspector when you are coding, you always looking for objects. Try it out. ;-)

Upvotes: 1

las
las

Reputation: 288

In CoreData if you use "new..." in attribute (compile normally) it will crash randomly with a "bad access" exception.

There is no crash log and the line shown with the "All Exceptions Breakpoint" will not help you at all.

Upvotes: 4

sooop
sooop

Reputation: 136

ARC does not allow to use "New...." in property name. but you can use "newTitle" by changing getter name. 

@property (nonatomic, strong, getter=theNewTitle) NSString *newTitle;

Upvotes: 10

Serge Rykovski
Serge Rykovski

Reputation: 63

Writing a setter manually with the name same as the property's removed this warning.

Upvotes: 3

aquraishi
aquraishi

Reputation: 137

It doesn't look like what Bavarious was suggesting was what you wanted to do. All you want to do is declare an instance variable NewTitle and then synthesize the property. We used to have to declare the instance variable and property. No more.

Now, I believe the right way of doing this is the following:

.h

@interface ViewController : UIViewController

@property (nonatomic, strong) NSString *newTitle;

.m

@synthesize newTitle = _newTitle; // Use instance variable _newTitle for storage

The instance variable for the property newTitle is synthesized. You don't want your instance variable to be the same as your property - too easy to make mistakes.

See Example: Declaring Properties and Synthesizing Accessors

Upvotes: 6

Michael
Michael

Reputation: 311

The name of the member starting with new is what triggers the warning. Change the name to editedTitle and the warning will go away. I was unable to find documentation confirming this but through testing was able to determine that member variables that begin with 'new' aggravate the compiler.

Upvotes: 31

Gypsa
Gypsa

Reputation: 11314

try this:-

@property (nonatomic,retain) NSString *newTitle;

Upvotes: -2

Related Questions