[Java.Interop] Cleanup: Kill JniMarshalMethod.

JniMarshalMethod contained System.Linq.Expressions-using code to wrap
an ~arbitrary delegate with a new delegate which, when invoked, will
create a JniTransition instance, a try/catch block, and invoke the
"source" delegate within the try/catch block for exception marshaling.

Which is ~identical to what Java.Interop.ExportedMemberBuilder does!

Which means we (kinda/sorta) had two different ways to do the same
thing...except where they weren't *identical*:

 1. JniMarshalMethod was used from JniType.RegisterNativeMethods()
 2. JniMarshalMethod supported "direct" methods.

A "direct" method is a method which would skip the "normal" generated
marshaling infrastructure and support passing *all* parameters, as-is,
to the wrapped delegate. JavaProxyObject made use of this to register
e.g. java.lang.Object.hashCode() and delegate the implementation to
System.Object.GetHashCode(). ExportedMemberBuilder didn't support
this.

Additionally, (1) introduced an implementation discrepency between
Xamarin.Android and Java.Interop: JniMarshalMethod was NOT used in
Xamarin.Android (to avoid additional runtime code generation).

Clean this up by improving ExportedMemberBuilder to support direct
method invocations, and then remove JniMarshalMethod.

Note: checking for "direct methods" is done via heuristic: if the
method has *at least* two parameters, and the first two parameters are
System.IntPtr, then it is assumed to be a direct method.

Fix JavaProxyObject and ManagedPeer so that they manually manage the
JniTransition paradigm (commit 3cd8310), avoiding the need for
System.Linq.Expressions use within Java.Interop.dll.

Review JniRuntime.JniExportedMemberBuilder API, "push down" core
methods that tools/jnimarshalmethod-gen uses so that
ExportedMemberBuilder doesn't need to be used directly, but instead
jnimarshalmethod-gen uses JniRuntime.ExportedMemberBuilder instead.

Author: jonpryor

src/Java.Interop.Export/Java.Interop/ExportedMemberBuilder.cs

@@ -24,6 +24,14 @@ public ExportedMemberBuilder (JniRuntime runtime)
 			OnSetRuntime (runtime);
 		}
 
+		public override LambdaExpression CreateMarshalToManagedExpression (MethodInfo method)
+		{
+			if (method == null)
+				throw new ArgumentNullException (nameof (method));
+
+			return CreateMarshalToManagedExpression (method, null, method.DeclaringType);
+		}
+
 		public override IEnumerable<JniNativeMethodRegistration> GetExportedMemberRegistrations (Type declaringType)
 		{
 			if (declaringType == null)
@@ -38,33 +46,31 @@ IEnumerable<JniNativeMethodRegistration> CreateExportedMemberRegistrationIterato
 				if (exports == null || exports.Length == 0)
 					continue;
 				var export  = exports [0];
-				yield return CreateMarshalFromJniMethodRegistration (export, declaringType, method);
+				yield return CreateMarshalToManagedMethodRegistration (export, method, declaringType);
 			}
 		}
 
-		public JniNativeMethodRegistration CreateMarshalFromJniMethodRegistration (JavaCallableAttribute export, Type type, MethodInfo method)
+		public JniNativeMethodRegistration CreateMarshalToManagedMethodRegistration (JavaCallableAttribute export, MethodInfo method, Type type = null)
 		{
 			if (export == null)
 				throw new ArgumentNullException ("export");
-			if (type == null)
-				throw new ArgumentNullException ("type");
 			if (method == null)
 				throw new ArgumentNullException ("method");
 
 			string signature = GetJniMethodSignature (export, method);
 			return new JniNativeMethodRegistration () {
 				Name        = GetJniMethodName (export, method),
 				Signature   = signature,
-				Marshaler   = CreateJniMethodMarshaler (export, type, method),
+				Marshaler   = CreateJniMethodMarshaler (method, export, type),
 			};
 		}
 
-		protected virtual string GetJniMethodName (JavaCallableAttribute export, MethodInfo method)
+		string GetJniMethodName (JavaCallableAttribute export, MethodInfo method)
 		{
 			return export.Name ?? "n_" + method.Name;
 		}
 
-		public virtual string GetJniMethodSignature (JavaCallableAttribute export, MethodInfo method)
+		public string GetJniMethodSignature (JavaCallableAttribute export, MethodInfo method)
 		{
 			if (export == null)
 				throw new ArgumentNullException ("export");
@@ -75,7 +81,8 @@ public virtual string GetJniMethodSignature (JavaCallableAttribute export, Metho
 				return export.Signature;
 
 			var signature = new StringBuilder ().Append ("(");
-			foreach (var p in method.GetParameters ()) {
+			var methodParameters    = method.GetParameters ();
+			foreach (var p in IsDirectMethod (methodParameters) ? methodParameters.Skip (2) : methodParameters) {
 				signature.Append (GetTypeSignature (p));
 			}
 			signature.Append (")");
@@ -97,28 +104,26 @@ string GetTypeSignature (ParameterInfo p)
 			throw new NotSupportedException ("Don't know how to determine JNI signature for parameter type: " + p.ParameterType.FullName + ".");
 		}
 
-		Delegate CreateJniMethodMarshaler (JavaCallableAttribute export, Type type, MethodInfo method)
+		Delegate CreateJniMethodMarshaler (MethodInfo method, JavaCallableAttribute export, Type type)
 		{
-			var e = CreateMarshalFromJniMethodExpression (export, type, method);
+			var e = CreateMarshalToManagedExpression (method, export, type);
 			return e.Compile ();
 		}
 
-		// TODO: make internal, and add [InternalsVisibleTo] for Java.Interop.Export-Tests
-		public virtual LambdaExpression CreateMarshalFromJniMethodExpression (JavaCallableAttribute export, Type type, MethodInfo method)
+		public LambdaExpression CreateMarshalToManagedExpression (MethodInfo method, JavaCallableAttribute callable, Type type = null)
 		{
-			if (export == null)
-				throw new ArgumentNullException ("export");
-			if (type == null)
-				throw new ArgumentNullException ("type");
 			if (method == null)
 				throw new ArgumentNullException ("method");
+			type        = type ?? method.DeclaringType;
 
 			var methodParameters = method.GetParameters ();
 
-			CheckMarshalTypesMatch (method, export.Signature, methodParameters);
+			CheckMarshalTypesMatch (method, callable?.Signature, methodParameters);
 
-			var jnienv  = Expression.Parameter (typeof (IntPtr), "__jnienv");
-			var context = Expression.Parameter (typeof (IntPtr), method.IsStatic ? "__class" : "__this");
+			bool direct = IsDirectMethod (methodParameters);
+
+			var jnienv  = Expression.Parameter (typeof (IntPtr), direct ? methodParameters [0].Name : "__jnienv");
+			var context = Expression.Parameter (typeof (IntPtr), direct ? methodParameters [1].Name : (method.IsStatic ? "__class" : "__this"));
 
 			var envp        = Expression.Variable (typeof (JniTransition), "__envp");
 			var jvm         = Expression.Variable (typeof (JniRuntime), "__jvm");
@@ -146,7 +151,17 @@ public virtual LambdaExpression CreateMarshalFromJniMethodExpression (JavaCallab
 			var invokeParameters    = new List<Expression> (methodParameters.Length);
 			for (int i = 0; i < methodParameters.Length; ++i) {
 				var marshaler   = GetValueMarshaler (methodParameters [i]);
-				var np          = Expression.Parameter (marshaler.MarshalType, methodParameters [i].Name);
+				ParameterExpression np;
+				if (i > 1 || !direct)
+					np = Expression.Parameter (marshaler.MarshalType, methodParameters [i].Name);
+				else {
+					if (i == 0)
+						np = jnienv;
+					else if (i == 1)
+						np = context;
+					else
+						throw new InvalidOperationException ("Should not be reached.");
+				}
 				var p           = marshaler.CreateParameterToManagedExpression (marshalerContext, np, methodParameters [i].Attributes, methodParameters [i].ParameterType);
 				marshalParameters.Add (np);
 				invokeParameters.Add (p);
@@ -190,10 +205,14 @@ public virtual LambdaExpression CreateMarshalFromJniMethodExpression (JavaCallab
 				envpBody.Add (Expression.Label (exit, Expression.Default (jniRType)));
 			}
 
-			var funcTypeParams = new List<Type> () {
-				typeof (IntPtr),
-				typeof (IntPtr),
-			};
+			var funcTypeParams  = new List<Type> ();
+			var bodyParams      = new List<ParameterExpression> ();
+			if (!direct) {
+				funcTypeParams.Add (typeof (IntPtr));
+				funcTypeParams.Add (typeof (IntPtr));
+				bodyParams.Add (jnienv);
+				bodyParams.Add (context);
+			}
 			foreach (var p in marshalParameters)
 				funcTypeParams.Add (p.Type);
 			if (ret != null)
@@ -202,14 +221,24 @@ public virtual LambdaExpression CreateMarshalFromJniMethodExpression (JavaCallab
 				? Expression.GetActionType (funcTypeParams.ToArray ())
 				: Expression.GetFuncType (funcTypeParams.ToArray ());
 
-			var bodyParams = new List<ParameterExpression> { jnienv, context };
 			bodyParams.AddRange (marshalParameters);
 			var body = Expression.Block (envpVars, envpBody);
 			return Expression.Lambda (marshalerType, body, bodyParams);
 		}
 
+		// Heuristic: if first two parameters are IntPtr, this is a "direct" wrapper.
+		static bool IsDirectMethod (ParameterInfo[] methodParameters)
+		{
+			return methodParameters.Length >= 2 &&
+				methodParameters [0].ParameterType == typeof (IntPtr) &&
+				methodParameters [1].ParameterType == typeof (IntPtr);
+		}
+
 		JniValueMarshaler GetValueMarshaler (ParameterInfo parameter)
 		{
+			if (parameter.ParameterType == typeof(IntPtr))
+				return IntPtrValueMarshaler.Instance;
+
 			var attr = parameter.GetCustomAttribute<JniValueMarshalerAttribute> ();
 			if (attr != null) {
 				return (JniValueMarshaler) Activator.CreateInstance (attr.MarshalerType);
@@ -223,8 +252,14 @@ void CheckMarshalTypesMatch (MethodInfo method, string signature, ParameterInfo[
 				return;
 
 			var mptypes = JniSignature.GetMarshalParameterTypes (signature).ToList ();
+			int rpcount = methodParameters.Length;
 			int len     = Math.Min (methodParameters.Length, mptypes.Count);
-			for (int i = 0; i < len; ++i) {
+			int start   = 0;
+			if (IsDirectMethod (methodParameters)) {
+				start   += 2;
+				rpcount -= 2;
+			}
+			for (int i = start; i < len; ++i) {
 				var vm  = GetValueMarshaler (methodParameters [i]);
 				var jni = vm.MarshalType;
 				if (mptypes [i] != jni)
@@ -233,31 +268,32 @@ void CheckMarshalTypesMatch (MethodInfo method, string signature, ParameterInfo[
 							"signature");
 			}
 
-			if (mptypes.Count != methodParameters.Length)
+			if (mptypes.Count != rpcount)
 				throw new ArgumentException (
 						string.Format ("JNI parametr count mismatch: signature contains {0} parameters, method contains {1}.",
 							mptypes.Count, methodParameters.Length),
-						"signature");
+						nameof (signature));
 
 			var jrinfo = JniSignature.GetMarshalReturnType (signature);
 			var mrvm   = GetValueMarshaler (method.ReturnParameter);
 			var mrinfo = mrvm.MarshalType;
 			if (mrinfo != jrinfo)
 				throw new ArgumentException (
 						string.Format ("JNI return type mismatch. Type '{0}' != '{1}'.", jrinfo, mrinfo),
-						"signature");
+						nameof (signature));
 		}
 
+		static ConstructorInfo  JniTransitionConstructor    =
+			(from c in typeof (JniTransition).GetTypeInfo ().DeclaredConstructors
+			 let  p = c.GetParameters ()
+			 where p.Length == 1 && p [0].ParameterType == typeof (IntPtr)
+			 select c)
+			.First ();
+
 		static Expression CreateJniTransition (ParameterExpression jnienv)
 		{
-			var ctor =
-				(from c in typeof(JniTransition).GetTypeInfo ().DeclaredConstructors
-				 let p = c.GetParameters ()
-				 where p.Length == 1 && p [0].ParameterType == typeof (IntPtr)
-				 select c)
-				.First ();
 			return Expression.New (
-					ctor,
+					JniTransitionConstructor,
 					jnienv);
 		}
 
@@ -364,5 +400,65 @@ static Type ExtractMarshalTypeFromSignature (string signature, ref int index)
 			#endif
 		}
 	}
+
+	class IntPtrValueMarshaler : JniValueMarshaler<IntPtr> {
+		internal    static  IntPtrValueMarshaler Instance = new IntPtrValueMarshaler ();
+
+		public override Expression CreateParameterFromManagedExpression (JniValueMarshalerContext context, ParameterExpression sourceValue, ParameterAttributes synchronize)
+		{
+			return sourceValue;
+		}
+
+		public override Expression CreateParameterToManagedExpression (JniValueMarshalerContext context, ParameterExpression sourceValue, ParameterAttributes synchronize, Type targetType)
+		{
+			return sourceValue;
+		}
+
+		public override Expression CreateReturnValueFromManagedExpression (JniValueMarshalerContext context, ParameterExpression sourceValue)
+		{
+			return sourceValue;
+		}
+
+
+		public override object CreateValue (ref JniObjectReference reference, JniObjectReferenceOptions options, Type targetType)
+		{
+			throw new NotImplementedException ();
+		}
+
+		public override IntPtr CreateGenericValue (ref JniObjectReference reference, JniObjectReferenceOptions options, Type targetType)
+		{
+			throw new NotImplementedException ();
+		}
+
+		public override JniValueMarshalerState CreateArgumentState (object value, ParameterAttributes synchronize)
+		{
+			throw new NotSupportedException ();
+		}
+
+		public override JniValueMarshalerState CreateGenericArgumentState (IntPtr value, ParameterAttributes synchronize)
+		{
+			throw new NotSupportedException ();
+		}
+
+		public override JniValueMarshalerState CreateObjectReferenceArgumentState (object value, ParameterAttributes synchronize)
+		{
+			throw new NotImplementedException ();
+		}
+
+		public override JniValueMarshalerState CreateGenericObjectReferenceArgumentState (IntPtr value, ParameterAttributes synchronize)
+		{
+			throw new NotImplementedException ();
+		}
+
+		public override void DestroyArgumentState (object value, ref JniValueMarshalerState state, ParameterAttributes synchronize)
+		{
+			throw new NotImplementedException ();
+		}
+
+		public override void DestroyGenericArgumentState (IntPtr value, ref JniValueMarshalerState state, ParameterAttributes synchronize)
+		{
+			throw new NotImplementedException ();
+		}
+	}
 }