Add support for nullable out/ref parameters in the generator

[rolfbjarne]

Nullable out/ref variables are annoying, because they can't be expressed with a single (nice) signature.

Example:

- (void)doSomething:(nullable CGRect *)rect;

I suggest adding generator support for generating multiple functions for this, by specifying the Nullable attribute on the out/ref argument (I'll stick with just ref in the sample to make it simpler, but it applies to both variations):

[Export ("doSomething:")]
void DoSomething ([Nullable] ref CGRect rect);

would produce:

// This is for subclassing & overriding the implementation.
[Export ("doSomething:")]
protected virtual void DoSomething (IntPtr rect)
{
    objc_msgSend (...);
}

// Two overloads with nicer signatures.
public void DoSomething ()
{
    return DoSomething (IntPtr.Zero);
}

public void DoSomething (ref CGRect rect)
{
    unsafe {
        fixed (void *refarg1 = &rect)
            DoSomething ((IntPtr) refarg1);
    }
}

[spouliot]

• The number of overloads could be more than two - e.g. there can be more than a single parameter and more than one CGRect* (or any nullable ref to a structure) in the signature. That might produce confusing or even invalid overloads;

protected virtual void DoSomething (IntPtr rect1, IntPtr rect2);

public void DoSomething ();
public void DoSomething (ref CGRect rect1);
public void DoSomething (ref CGRect rect2); // invalid, duplicate signature
public void DoSomething (ref CGRect rect1, ref CGRect rect2);

a ref GCRect? rect might help - but it's not a nice signature :|

• A solution is also needed if a CGRect* is returned from the bound function(s);

[rolfbjarne]

Yes, if there are multiple nullable ref/out parameters things become more complicated.

And yes, such signatures exist: https://github.com/xamarin/xamarin-macios/blob/8e32ace58e485bd6ae3ba331b28ba7ac14e2c30b/src/appkit.cs#L10570

ref CGRect? is not a bad idea, but it's a lot more work (it would require updates to the static registrar and runtime trampolines).

That said, we could say that we only support signatures with a single nullable ref/out parameter, which should catch the great majority of cases.

[rolfbjarne]

Actually the convenience methods with ref CGRect? would not be exported, so there shouldn't be more complicated to implement.

[rolfbjarne]

Another option is to bind using pointers:

[Export ("doSomething:")]
void DoSomething ([Nullable] CGRect* rect);

The meaning of the [Nullable] attribute is somewhat overloaded here though (the argument isn't nullable from a C# perspective), so we could come up with a different attribute:

[Export ("doSomething:")]
void DoSomething ([AllowNullPointer] CGRect* rect);