Better protocols

[madsmtm]

Fixes #291.

TODO:

• Finish basic implementation
• Update documentation
• Use new implementation for NSCopying, NSMutableCopying, ... Deferred to Fix NSCopying and NSMutableCopying #401
• Test assembly output to ensure that using dyn like this doesn't incur extra overhead
  • It doesn't, see this godbolt.

[madsmtm]

A somewhat end-goal is that we can use this in icrate for translating places that take/return something like id<NSMutableCopying + NSFastEnumeration> to:

ProtocolObject<dyn NSMutableCopying + NSFastEnumeration>

// where:
// trait NSMutableCopying: NSCopying { ... }
// trait NSFastEnumeration { ... }

To use such an object, we would like the following implementations to exist:

// Required to use the object at all
impl NSCopying for ProtocolObject<dyn NSMutableCopying + NSFastEnumeration> {}
impl NSMutableCopying for ProtocolObject<dyn NSMutableCopying + NSFastEnumeration> {}
impl NSFastEnumeration for ProtocolObject<dyn NSMutableCopying + NSFastEnumeration> {}

// Would be nice to have
impl ConformsTo<dyn NSCopying> for ProtocolObject<dyn NSMutableCopying + NSFastEnumeration> {}
impl ConformsTo<dyn NSMutableCopying> for ProtocolObject<dyn NSMutableCopying + NSFastEnumeration> {}
impl ConformsTo<dyn NSFastEnumeration> for ProtocolObject<dyn NSMutableCopying + NSFastEnumeration> {}

// Not really that important, but could be cool
impl ConformsTo<dyn NSCopying + NSFastEnumeration> for ProtocolObject<dyn NSMutableCopying + NSFastEnumeration> {}
impl ConformsTo<dyn NSMutableCopying + NSFastEnumeration> for ProtocolObject<dyn NSMutableCopying + NSFastEnumeration> {}

---

// For an object `MyClass` that implements the protocols, these are required
impl NSCopying for MyClass {}
impl NSMutableCopying for MyClass {}
impl NSFastEnumeration for MyClass {}

// And these would be expected
impl ConformsTo<dyn NSCopying> for MyClass {}
impl ConformsTo<dyn NSMutableCopying> for MyClass {}
impl ConformsTo<dyn NSFastEnumeration> for MyClass {}

// To properly handle the case above, these would be nice
impl ConformsTo<dyn NSCopying + NSFastEnumeration> for MyClass {}
impl ConformsTo<dyn NSMutableCopying + NSFastEnumeration> for MyClass {}

Note: dyn TraitA + TraitB + ... is not yet possible in Rust unless only one of them is a non-auto trait. But we still have to plan for the future!

[madsmtm]

I've been going about this a bit wrong; what we want is for users to specify this:

extern_protocol!(
    unsafe trait NSCopying {
        // ...
    }
);

extern_protocol!(
    unsafe trait NSMutableCopying: NSCopying {
        // ...
    }
);

extern_protocol!(
    unsafe trait NSFastEnumeration {
        // ...
    }
);

extern_class!(
    struct MyClass;
);

unsafe impl NSCopying for MyClass {}
unsafe impl NSMutableCopying for MyClass {}
unsafe impl NSFastEnumeration for MyClass {}

Notice how the protocol implementations for the class is not in the extern_class! macro? That's intentional, since the protocol may be specified in a "later"/"higher up" framework than the class is (which would work for Objectice-C, since they'd just define a category, but it won't work for us).

Additionally, the use of ConformsTo is entirely hidden, which is also really nice!

[madsmtm]

Implementation-wise:

extern_protocol!(
    unsafe trait FooBar: Foo + Bar {}
);

// Generates

unsafe trait FooBar: ... {...}

unsafe impl<T: ?Sized + FooBar> FooBar for ProtocolObject<T> {}

// Note: Needs to be done a bit differently because of the orphan rule
impl<T: ?Sized + FooBar> ConformsTo<dyn FooBar> for T {}

// Maybe?
// impl<T: ?Sized + FooBar> ConformsTo<dyn Foo> for T {}
// impl<T: ?Sized + FooBar> ConformsTo<dyn Bar> for T {}