Why ARC forbids calls to undeclared methods?

Question

When using manual memory management we can write a call to a method which is not declared in the class. What we get during compilation in this case is warning only. This is

Answer 1

ARC manages retain/release calls. To do so properly it needs to know how all methods you use behave.

It needs the message signatures you use. it gets them from header files. Therefore it enforces you to have headers/declarations for all methods you use.

It DOES work without headers: you can trick it by using NSSelectorFromString but that isn't really safe and arc wants to be sure about everything by default.

Answer 2

There is some information about it in this discussion:

• http://lists.apple.com/archives/objc-language/2012/Jul/msg00110.html

Under ARC, the compiler needs to now exactly the kind of ownership the method returns. The default in this case is that the object is not owned by the caller, but in the actual declaration the object may be owned by the caller ("ns_returns_retained" attribute), conversely, you may have a owning method like newBar that returns a non-retained object ("ns_returns_not_retained" attribute), in the former case you get an under-release in the latter you get an over-release, which is detrimental to ARC.

To make ARC deterministic, the compiler has to assume a lot of things so certain behaviours that were okay before are made illegal in ARC to ensure that the behaviour is consistent.

And this response seems to be from one of the Apple developers:

• http://lists.apple.com/archives/objc-language/2012/Jul/msg00114.html

Our reasoning was split about 50/50 between (1) needing to be more careful about types and ownership and (2) wanting to eliminate an embarrassing wart in the language (not being allowed to complain about completely unknown methods with anything more strenuous than a warning). There is really no legitimate reason to call a method that's not even declared somewhere. The ability to do this makes some really trivial bugs (e.g. typos in selectors) runtime failures instead of compile failures. We have always warned about it. Fix your code.

So the main argument is that the compiler needs to know the ownership of the return value.