[Java.Interop.Dynamic] Support accessing static int fields.

(I now understand the DLR enough to be slightly dangerous.)

Implement enough DLR voodoo so that static int fields can be accessed
and read; from a unit test:

	dynamic Integer = new DynamicJavaClass ("java/lang/Integer");
	int max = Integer.MAX_VALUE;

Yes, that works, and yes, it is awesome. It reads the
Integer.MAX_VALUE field.

Doubly awesome -- and a huge part of the complication! -- is that it
uses DynamicMetaObject.BindConvert() to detect that the field type
is `int`, as field type information is required in order to lookup the
field, and thus we need to delay the actual JNI field lookup and
access until *after* we know the desired type. Figuring out how to
actually support this took a fair bit of banging my head against
several walls...

...and since the DLR documentation is horribly inadequate, requiring
that I go spelunking through their source...

A Short DLR Primer:

The DLR is ~wholly based upon Systme.Linq.Expressions. A type may
participate in the DLR by implementing the IDynamicMetaObjectProvider
interface and subclassing the DynamicMetaObject class.

DynamicMetaObject does the "heavy lifting" of Expression manipulation
in order to perform the desired actions.

The problem, sanity wise, is understanding BindingRestrictions use,
which is likewise underdocumented:

			return new DynamicMetaObject(
					Expression,
					BindingRestrictions.GetTypeRestriction(
						Expression,
						typeof (DynamicJavaClass)));

AFAICT, BindingRestrictions is used by the DLR to assist in
"invalidating" the cached callsite information (as LOTS of information
is cached at the callsite in order to assist performance).

The above states that `Expression` will be of type `DynamicJavaClass`,
via BindingRestrictions.Get*Type*Restriction(), and thus:

 1. If the cached type is NOT DynamicJavaClass, then it's the cached
    value, and nothing more need be done.
 2. If the cached type IS DynamicJavaClass, then
    DynamicJavaClass.GetMetaObject() should be invoked for future DLR
    operations.

The problem regarding the above "don't do anything until we get a
BindConvert() request!" logic is that BindConvert() is *last*.
Furthermore, DynamicMetaObject instances are recreated ALL THE TIME,
so accessing a static field:

	var value = Integer.MAX_VALUE;

Results in (paraphrasing greatly!):

	var metaObject  = Integer.GetMetaObject();
	var valueObject = metaObject.BindGetMember(... "MAX_VALUE" ... );
	var value       = valueObject.Compile().Invoke (...);

At this point `value` is compared against the BindingRestrictions; if
BindingRestrictions is set improperly, then `value` is used AS-IS,
there is no later BindConvert() call, and there's no way to determine
the intended field type. (Exceptions soon follow.)

So to make this work the MetaStaticMemberAccessObject.BindGetMember()
method needs to restrict the value to a StaticFieldAccess, which is
created via System.Linq.Expressions, so that the StaticFieldAccess can
participate in the DLR binding logic.

StaticFieldAccess holds the accessed field and, in turn, implements
the IDynamicMetaObjectProvider to return a MetaStaticFieldAccessObject,
which overrides BindConvert() and delegates the call to
DynamicJavaClass.GetStaticFieldValue(), which allows providing both
the accessed field AND the desired return type, allowing this miracle
to actually work.

Huzzah!

Author: jonpryor

src/Java.Interop.Dynamic/Java.Interop.Dynamic.csproj

@@ -37,4 +37,14 @@
     <Compile Include="Java.Interop.Dynamic\DynamicJavaClass.cs" />
   </ItemGroup>
   <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
+  <ItemGroup>
+    <ProjectReference Include="..\..\lib\mono.linq.expressions\Mono.Linq.Expressions.csproj">
+      <Project>{0C001D50-4176-45AE-BDC8-BA626508B0CC}</Project>
+      <Name>Mono.Linq.Expressions</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\Java.Interop\Java.Interop.csproj">
+      <Project>{94BD81F7-B06F-4295-9636-F8A3B6BDC762}</Project>
+      <Name>Java.Interop</Name>
+    </ProjectReference>
+  </ItemGroup>
 </Project>

src/Java.Interop.Dynamic/Java.Interop.Dynamic/DynamicJavaClass.cs

@@ -4,35 +4,89 @@
 using System.Dynamic;
 using System.Linq;
 using System.Linq.Expressions;
+using System.Reflection;
+using System.Reflection.Emit;
 using System.Text;
 
+using Mono.Linq.Expressions;
+
 using Java.Interop;
 
 namespace Java.Interop.Dynamic {
 
 	public class DynamicJavaClass : IDynamicMetaObjectProvider
 	{
-		public DynamicMetaObject GetMetaObject(Expression parameter)
+		public  string          JniClassName            {get; private set;}
+
+		JniPeerMembers          members;
+
+		public DynamicJavaClass (string jniClassName)
+		{
+			if (jniClassName == null)
+				throw new ArgumentNullException ("jniClassName");
+
+			JniClassName    = jniClassName;
+			members         = new JniPeerMembers (jniClassName, CreateManagedPeerType ());
+		}
+
+		DynamicMetaObject IDynamicMetaObjectProvider.GetMetaObject (Expression parameter)
+		{
+			return new MetaStaticMemberAccessObject (parameter, this);
+		}
+
+		public object GetStaticFieldValue (string fieldName, Type fieldType)
+		{
+			Console.WriteLine ("# DynamicJavaClass({0}).field({1}) as {2}", JniClassName, fieldName, fieldType);
+			var typeInfo    = JniEnvironment.Current.JavaVM.GetJniTypeInfoForJniTypeReference (JniClassName);
+			switch (typeInfo.ToString ()) {
+			case "I":
+			case "java/lang/Integer":   // WTF?
+				return members.StaticFields.GetInt32Value (fieldName + "\u0000I");
+			}
+			return null;
+		}
+
+		internal StaticFieldAccess GetStaticFieldAccess (string fieldName)
+		{
+			return new StaticFieldAccess (this, fieldName);
+		}
+
+		Type CreateManagedPeerType ()
 		{
-			return new MyMetaObject(parameter, this);
+			var className   = JniClassName.Replace ('/', '-');
+			var aname       = new AssemblyName ("Java.Interop.Dynamic-" + className);
+
+			var assembly    = AppDomain.CurrentDomain.DefineDynamicAssembly (aname, AssemblyBuilderAccess.ReflectionOnly);
+			var module      = assembly.DefineDynamicModule (className);
+			var type        = module.DefineType (JniClassName, TypeAttributes.Sealed, typeof (JavaObject));
+			type.SetCustomAttribute (
+					new CustomAttributeBuilder (
+						typeof (JniTypeInfoAttribute).GetConstructor (new[]{ typeof(string) }),
+						new []{JniClassName}));
+
+			return type.CreateType ();
 		}
 	}
 
-	public class MyMetaObject : DynamicMetaObject
+	class MetaStaticMemberAccessObject : DynamicMetaObject
 	{
-		public MyMetaObject(Expression parameter, object value)
+		public MetaStaticMemberAccessObject (Expression parameter, object value)
 			: base(parameter, BindingRestrictions.Empty, value)
 		{
+			Console.WriteLine ("# MyMetaObject..ctor: paramter={0} {1} {2}", parameter.ToCSharpCode (), parameter.GetType (), parameter.Type);
+			Console.WriteLine ("# MyMetaObject..ctor: value={0} {1}", value, value.GetType ());
 		}
 
 		public override DynamicMetaObject BindConvert(ConvertBinder binder)
 		{
+			Console.WriteLine ("Convert: Expression={0} [{1}]", Expression.ToCSharpCode (), Expression.Type);
 			return this.PrintAndReturnIdentity("Convert: Explicit={0}; ReturnType={1}; Type={2}", binder.Explicit, binder.ReturnType, binder.Type);
 		}
 
 		public override DynamicMetaObject BindInvokeMember(InvokeMemberBinder binder, DynamicMetaObject[] args)
 		{
-			return this.PrintAndReturnIdentity("InvokeMember of method {0}", binder.Name);
+			return this.PrintAndReturnIdentity("InvokeMember of method={0}; ReturnType={1}; args={{{2}}}; CallInfo={3}", binder.Name, binder.ReturnType,
+				string.Join (", ", args.Select (a => string.Format ("{0} [{1}]", a.Expression.ToCSharpCode (), a.LimitType))), binder.CallInfo);
 		}
 
 		public override DynamicMetaObject BindSetMember(SetMemberBinder binder, DynamicMetaObject value)
@@ -42,7 +96,17 @@ public override DynamicMetaObject BindSetMember(SetMemberBinder binder, DynamicM
 
 		public override DynamicMetaObject BindGetMember(GetMemberBinder binder)
 		{
-			return this.PrintAndReturnIdentity("GetMember of property {0}", binder.Name);
+			Console.WriteLine ("GetMember: Expression={0} [{1}]; property={2}", Expression.ToCSharpCode (), Expression.Type, binder.Name);
+			var expr =
+				Expression.Call (
+					Expression.Convert (Expression, typeof(DynamicJavaClass)),
+					typeof (DynamicJavaClass).GetMethod ("GetStaticFieldAccess", BindingFlags.Instance | BindingFlags.NonPublic),
+					Expression.Constant (binder.Name));
+			return new DynamicMetaObject (
+				expr,
+				BindingRestrictions.GetTypeRestriction (
+					expr,
+					typeof (StaticFieldAccess)));
 		}
 
 		private DynamicMetaObject PrintAndReturnIdentity(string message, params object[] args)
@@ -55,6 +119,51 @@ private DynamicMetaObject PrintAndReturnIdentity(string message, params object[]
 					typeof (DynamicJavaClass)));
 		}
 	}
+	class StaticFieldAccess : IDynamicMetaObjectProvider {
+
+		public  string              FieldName   {get; private set;}
+		public  DynamicJavaClass    JavaClass   {get; private set;}
+
+		public StaticFieldAccess (DynamicJavaClass klass, string fieldName)
+		{
+			JavaClass = klass;
+			FieldName = fieldName;
+		}
+
+		public DynamicMetaObject GetMetaObject(Expression parameter)
+		{
+			Console.WriteLine ("# FieldAccessInfo.GetMetaObject: parameter={0}", parameter);
+			return new MetaStaticFieldAccessObject(parameter, this);
+		}
+	}
+
+	class MetaStaticFieldAccessObject : DynamicMetaObject {
+
+		public MetaStaticFieldAccessObject (Expression e, object value)
+			: base (e, BindingRestrictions.Empty, value)
+		{
+			Console.WriteLine ("MyHelperObject: e={0}", e.ToCSharpCode ());
+		}
+
+		public override DynamicMetaObject BindConvert (ConvertBinder binder)
+		{
+			Console.WriteLine ("MetaStaticFieldAccessObject.Convert: Expression={0} [{1}]", Expression.ToCSharpCode (), Expression.Type);
+
+			var field       = Expression.Convert(Expression, typeof(StaticFieldAccess));
+			var instance    = Expression.Property (field, "JavaClass");
+			var fieldName   = Expression.Property (field, "FieldName");
+			var gsfv        = typeof(DynamicJavaClass).GetMethod ("GetStaticFieldValue");
+			var expr        = Expression.Convert (
+					Expression.Call (instance, gsfv, fieldName, Expression.Constant (binder.Type)),
+                    binder.Type);
+			return new DynamicMetaObject (
+					expr,
+					BindingRestrictions.GetTypeRestriction (
+						expr,
+						binder.Type));
+		}
+	}
+
 #if false
 	public class DynamicJavaClass : DynamicObject {
 

src/Java.Interop.Dynamic/Tests/Java.Interop.Dynamic/DynamicJavaClassTests.cs

@@ -16,10 +16,17 @@ namespace Java.Interop.DynamicTests {
 	[TestFixture]
 	class DynamicJavaClassTests : JVM
 	{
+		[Test]
+		public void Constructor ()
+		{
+			Assert.Throws<ArgumentNullException> (() => new DynamicJavaClass (null));
+		}
+
 		[Test]
 		public void Frobnicate ()
 		{
-			dynamic d = new DynamicJavaClass ();
+			Console.WriteLine ("---");
+			dynamic d = new DynamicJavaClass ("java/lang/Object");
 
 			d.P3 = d.M1(d.P1, d.M2(d.P2));
 			Console.WriteLine ("--");
@@ -35,6 +42,14 @@ public void Frobnicate ()
 				Console.WriteLine (e);
 			}
 		}
+
+		[Test]
+		public void AccessStaticMember ()
+		{
+			dynamic Integer = new DynamicJavaClass ("java/lang/Integer");
+			int max = Integer.MAX_VALUE;
+			Assert.AreEqual (int.MaxValue, max);
+		}
 	}
 }