Защо ARC миграторът казва, че -setArgument: на NSInvocation не е безопасен, освен ако аргументът не е __unsafe_unretained?

Това е пълно предположение, но може ли да има нещо общо с аргумента, който се предава по препратка като void*?

В случая, който споменахте, това наистина не изглежда проблем, но ако се обадите напр. getArgument:atIndex: тогава компилаторът няма как да знае дали върнатият аргумент трябва да бъде запазен.

От NSInvocation.h:

- (void)getArgument:(void *)argumentLocation atIndex:(NSInteger)idx;
- (void)setArgument:(void *)argumentLocation atIndex:(NSInteger)idx;

Като се има предвид, че компилаторът не знае дали методът ще се върне по референция или не (тези две декларации на метода имат идентични типове и атрибути), може би миграторът е (разумно) предпазлив и ви казва да избягвате невалидни указатели към силни указатели?

Eg:

NSDecimalNumber* val;
[anInvocation getArgument:&val atIndex:2];
anInvocation = nil;
NSLog(@"%@", val); // kaboom!


__unsafe_unretained NSDecimalNumber* tempVal;
[anInvocation getArgument:&tempVal atIndex:2];
NSDecimalNumber* val = tempVal;
anInvocation = nil;
NSLog(@"%@", val); // fine

NSInvocation по подразбиране не запазва или копира дадени аргументи за ефективност, така че всеки обект, предаден като аргумент, трябва все още да е жив, когато се извиква извикването. Това означава, че указателите, предадени на -setArgument:atIndex:, се обработват като __unsafe_unretained.

Двата реда MRR код, които публикувахте, се разминаха с това: testNumber1 никога не беше пуснат. Това би довело до изтичане на памет, но щеше да свърши работа. В ARC обаче testNumber1 ще бъде освободен някъде между последното му използване и края на блока, в който е дефиниран, така че ще бъде освободен. При мигриране към ARC кодът може да се срине, така че инструментът за мигриране на ARC ви пречи да мигрирате:

SetArgument на NSInvocation не е безопасно да се използва с обект със собственост, различна от __unsafe_unretained

Простото предаване на указателя като __unsafe_unretained няма да реши проблема, трябва да се уверите, че аргументът все още е налице, когато се извика извикването. Един от начините да направите това е да извикате -retainArguments както направихте (или дори по-добре: директно след създаването на NSInvocation). Тогава извикването запазва всичките си аргументи и така запазва всичко необходимо за извикване. Това може да не е толкова ефективно, но определено е за предпочитане пред срив ;)

Защо ви пречи да направите това? Изглежда също толкова лошо да се използват __unsafe_unretained обекти като аргументи.

Съобщението за грешка може да бъде подобрено, но мигриращият не казва, че __unsafe_unretained обектите са безопасни за използване с NSInvocation (няма нищо безопасно с __unsafe_unretained, то е в името). Целта на грешката е да привлече вниманието ви, че предаването на силни/слаби обекти към този API не е безопасно, вашият код може да избухне по време на изпълнение и трябва да проверите кода, за да сте сигурни, че няма да го направи.

Като използвате __unsafe_unretained, вие основно въвеждате изрични опасни точки във вашия код, където поемате контрола и отговорността за това, което се случва. Добра хигиена е да направите тези опасни точки видими в кода, когато работите с NSInvocation, вместо да се подлагате на илюзията, че ARC ще се справи правилно с нещата с този API.

Излагам пълното си предположение тук.

Това вероятно е пряко свързано с retainArguments, който изобщо съществува при извикването. Като цяло всички методи описват как ще обработват всички аргументи, изпратени до тях с анотации директно в параметъра. Това не може да работи в случай NSInvocation, защото времето за изпълнение не знае какво ще направи извикването с параметъра. Целта на ARC е да направи всичко възможно, за да гарантира липса на течове, без тези анотации програмистът трябва да провери дали няма течове. Като ви принуждава да използвате __unsafe_unretained, ви принуждава да направите това.

Бих приписал това на една от странностите с ARC (други включват някои неща, които не поддържат слаби препратки).

Важното тук е стандартното поведение на NSInvocation: По подразбиране аргументите не се запазват и аргументите от C низове не се копират. Следователно под ARC вашият код може да се държи както следва:

// Creating the testNumber
NSDecimalNumber *testNumber1 = [[NSDecimalNumber alloc] initWithString:@"1.0"];

// Set the number as argument
[theInvocation setArgument:&testNumber1 atIndex:2];

// At this point ARC can/will deallocate testNumber1, 
// since NSInvocation does not retain the argument
// and we don't reference testNumber1 anymore

// Calling the retainArguments method happens too late.
[theInvocation retainArguments];

// This will most likely result in a bad access since the invocation references an invalid pointer or nil
[theInvocation invoke];

Следователно мигриращият ви казва: На този етап трябва изрично да се уверите, че обектът ви се запазва достатъчно дълго. Затова създайте променлива unsafe_unretained (където трябва да имате предвид, че ARC няма да я управлява вместо вас).

Според Apple Doc NSInvocation:

Този клас не запазва аргументите за съдържащото се извикване по подразбиране. Ако тези обекти могат да изчезнат между времето, когато създавате вашия екземпляр на NSInvocation и времето, когато го използвате, трябва изрично да запазите обектите сами или да извикате метода retainArguments, за да може обектът за извикване да ги запази сам.