Почему средство миграции ARC говорит, что NSInvocation -setArgument: небезопасен, если аргумент не является __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 и временем его использования, вы должны явно сохранить объекты самостоятельно или вызвать метод continueArguments, чтобы объект вызова сохранил их сам.