[generator] Add support for peerConstructorPartialMethod

[jonpryor]

Context: #1085
Context: dotnet/runtime#82121

Some Java objects are big, e.g. Bitmap instances, but as
far as MonoVM is concerned, the Bitmap instances are tiny: a
few pointers, and that's it. MonoVM doesn't know that it could be
referencing several MB of data in the Java VM.

MonoVM is gaining support for GC.AddMemoryPressure() and
GC.RemoveMemoryPressure(), which potentially allows for the
parent of all cross-VM GC integrations: using the GC methods to
inform MonoVM of how much non-managed memory has been allocated.
This could allow MonoVM to collect more frequently when total process
memory is low.

How should we call GC.AddMemoryPressure() and
GC.RemoveMemoryPressure()?

GC.RemoveMemoryPressure() is straightforward: a class can override
Java.Lang.Object.Dispose(bool).

GC.AddMemoryPressure() is the problem: where and how can it be
called from a class binding? This is trickier, as there was no way
to have custom code called by the bound type. Instead, various
forms of "hacky workarounds" are often employed, e.g. copying
generator-emitted content into a partial class, then using
metadata to prevent generator from binding those members.
It's all around fugly.

Fortunately C# has a solution: partial methods!

Add support for a peerConstructorPartialMethod metadata entry,
applicable to <class/> elements, which contains the name of a
partial method to both declare and invoke from the "peer constructor":

<attr
    path="//class[@name='Bitmap']"
    name="peerConstructorPartialMethod"
>_OnBitmapCreated</attr>

This will alter our existing "peer constructor" generation code, a'la:

partial class Bitmap : Java.Lang.Object {
    internal Bitmap (IntPtr h, JniHandleOwnership t) : base (h, t)
    {
    }
}

to instead become:

partial class Bitmap : Java.Lang.Object {
    partial void _OnBitmapCreated ();
    internal Bitmap (IntPtr h, JniHandleOwnership t) : base (h, t)
    {
        _OnBitmapCreated ();
    }
}

This allows a hand-written partial class Bitmap to do:

    // Hand-written code
    partial class Bitmap {
        int _memoryPressure;

        partial void _OnBitmapCreated ()
        {
            _memoryPressure = ByteCount;
            GC.AddMemoryPressure (_memoryPressure);
        }

        protected override void Dispose (bool disposing)
        {
            if (_memoryPressure != 0) {
                GC.RemoveMemoryPressure (_memoryPressure);
                _memoryPressure = 0;
            }
        }
    }

TODO: "extend" this for <method/>s as well?

[jonpryor]

The compilation overhead of partial methods appears to be negligeable: https://gist.github.com/jonpryor/16b918134fd6fc13b1b20afd10c936cb

[jonpryor]

dotnet/android#7886 looks "green enough" for this to be merge-worthy. This change doesn't appear to break anything.

[jpobst]

This way of implementation breaks the "spirit" of the SourceWriter model. That is, it is using a MethodWriter to write 2 methods.

This should instead be implemented as a new ConstructorPartialMethod : MethodWriter class in generator.csproj that gets added to the ClassWriter model when the JavaLangObjectConstructor is created.

ie, here:
https://github.com/jonpryor/java.interop/blob/jonp-ctor-calls-partial-method/tools/generator/SourceWriters/BoundClass.cs#L128-L130

Should be something like:

// Add required constructor for all JLO inheriting classes
if (klass.FullName != "Java.Lang.Object" && klass.InheritsObject) {
	Methods.Add (new ConstructorPartialMethod (klass, opt));
	Constructors.Add (new JavaLangObjectConstructor (klass, opt));
}

The only change we should need for MethodWriter is if it doesn't support partial methods in general.

[jpobst]

Excellent, thanks for the changes!