Array storing Any objects is also of AnyObject type

Question

let f: () -> Void = { }

let array = ["a", 1, false, f] as [Any]

if array[3] is AnyObject {
  print(array[3])
}

Why is the element evaluating to true for AnyObject even though the array is set to store Any?

Why is function evaluates to true as an AnyObject even though AnyObject by definition can only be classes?

As another example:

let f: () -> Bool = { return true }
let ff = f as AnyObject
(ff as () -> Bool)()

This goes against the definition of AnyObject in the API doc, which states that:

AnyObject can be used as the concrete type for an instance of any class, class type, or class-only protocol.

or the official Swift Programming Language Guide:

• Any can represent an instance of any type at all, including function types.

• AnyObject can represent an instance of any class type.

In the above example, it looks like function can be representated as AnyObject.

There is explanation elsewhere in SO (as pointed out by @hamish) that internally because SwiftValue class is used, anything can be bridged to AnyObject. The logic of explanation seems to be flawed/reverse, as we should make implementation conform to the language definition, not the other way around, so either the implementation is incorrect, or the definition of AnyObject and typecheck operator is incorrect?

Answer 1

First, the Swift Programming Language Guide is a not a language specification in the way that ISO 9899 defines C. (And even given an ISO standard, not every compiler implements C identically, or even in 100% accordance with the standard.) If you find a disagreement between the compiler and the documentation, it is just as likely to be a documentation bug as a compiler bug.

That said, I believe you've glossed over an important part of the spec you reference:

AnyObject can also be used as the concrete type for an instance of a type that bridges to an Objective-C class. Many value types in Swift bridge to Objective-C counterparts, like String and Int.

() -> Void is equivalent to dispatch_block_t, which bridges to ObjC as a dispatch_object (see dispatch/object.h and os/object.h):

/*
 * By default, dispatch objects are declared as Objective-C types when building
 * with an Objective-C compiler. This allows them to participate in ARC, in RR
 * management by the Blocks runtime and in leaks checking by the static
 * analyzer, and enables them to be added to Cocoa collections.
 * See <os/object.h> for details.
 */
OS_OBJECT_DECL_CLASS(dispatch_object);

So there is no surprise here that () -> Void can be coerced into AnyObject.

In practice, pretty much anything can now bridge into AnyObject (again, from a language specification point of view, anything that can be an NSValue can be an AnyObject, even though that's not exactly how it's implemented).

AnyObject is different than Any, however. Any behaves like a protocol (despite not being a protocol). AnyObject behaves like the superclass of every class (despite actually being a protocol).

let b = true                         // true
let bany = true as Any               // true
let banyobj = true as AnyObject      // 1 <=== (because it's NSNumber)

MemoryLayout.size(ofValue: b)        // 1 (size of a bool)
MemoryLayout.size(ofValue: bany)     // 32 (size of a protocol box)
MemoryLayout.size(ofValue: banyobj)  // 8 (size of a reference pointer)

type(of: b)                          // Bool.Type
type(of: bany)                       // Bool.Type
type(of: banyobj)                    // __NSCFBoolean.Type

(Try the same thing for {} to see how closures are handled.)

It is reasonable to open a defect against the AnyObject docs to include a more explicit explanation that any type can be converted into a reference type using as AnyObject, but this is just an omission, not a contradiction of what's already there. (And if it were a contradiction, or you find it confusing, then again, the correct answer is to open a defect to improve the docs to match Swift, not Swift to match the docs.)