[Java.Interop] Normalize JniType.Name on JNI convention.

java.lang.Class.getName() is...weird, at least on Desktop Java:
it is NOT the JNI value; `java.lang.Object.class.getName()` returns
"java.lang.Object", i.e. "Java" convention.

Nested types are some bizarre combination of Java & JNI:
`java.lang.Thread.State.class.getName()` returns
"java.lang.Thread$State", i.e. `$` is used to separate nested types,
as is done in JNI.

This is why JniType.Name already replaces s#\.#/#g, resulting in JNI
convention ('java/lang/Object', 'java/lang/Thread$State').

...except for builtin types: `int.class.getName()` returns "int",
*not* "I", EVEN THOUGH `int[].class.getName()` is "[I".
Ditto other arrays; `Object[].class.getName()` is
"[Ljava.lang.Object;", because why the hell not?

In short, Class.getName() is *really weird* about which convention
it's using, using either Java, JNI, or bastardized mixing of the two.

Which makes it difficult to sanely use the result of JniType.Name in
any other context, e.g. to generate JNI method signatures, because you
never know what the value is.

Fix that: JniType.Name shall henceforth return a value in JNI
convention, including for bulitin types: add a typename mapping from
the Java builtin values (e.g. "int") to their corresponding JNI values
(e.g. "I"), so that JniType.Name for an `int` is "I".

A problem, testing-wise: `new JniType("I")` and `new JniType("int")`
fail, because JNIEnv::FindClass() refuses to do anything with
builtins. (JNI bug?)

Thus, in order to *test* that JniType.Name for an `int` is "I", we
first need to convince the JVM to give us a Class instance for `int`.
To do *that*, we use JNI to invoke Java Reflection to lookup
java.lang.Object.hashCode(), which returns an int. This allows us to
get Java's `int.class`, allowing us to call `int.class.getName()` and
ensure that it is sanely mapped to "I", not "int".

Author: jonpryor

src/Java.Interop/Java.Interop/JniType.cs

@@ -11,6 +11,18 @@ namespace Java.Interop {
 
 	public sealed class JniType : IDisposable {
 
+		readonly    static  KeyValuePair<string, string>[]  BuiltinMappings = new KeyValuePair<string, string>[] {
+			new KeyValuePair<string, string>("byte",       "B"),
+			new KeyValuePair<string, string>("boolean",    "Z"),
+			new KeyValuePair<string, string>("char",       "C"),
+			new KeyValuePair<string, string>("double",     "D"),
+			new KeyValuePair<string, string>("float",      "F"),
+			new KeyValuePair<string, string>("int",        "I"),
+			new KeyValuePair<string, string>("long",       "J"),
+			new KeyValuePair<string, string>("short",      "S"),
+			new KeyValuePair<string, string>("void",       "V"),
+		};
+
 		public static unsafe JniType DefineClass (string name, JniReferenceSafeHandle loader, byte[] classFileData)
 		{
 			fixed (byte* buf = classFileData) {
@@ -46,8 +58,13 @@ public string Name {
 				AssertValid ();
 
 				var s = JniEnvironment.Current.Class_getName.CallVirtualObjectMethod (SafeHandle);
-				return JniEnvironment.Strings.ToString (s, JniHandleOwnership.Transfer)
+				var n = JniEnvironment.Strings.ToString (s, JniHandleOwnership.Transfer)
 					.Replace ('.', '/');
+				for (int i = 0; i < BuiltinMappings.Length; ++i) {
+					if (n == BuiltinMappings [i].Key)
+						return BuiltinMappings [i].Value;
+				}
+				return n;
 			}
 		}
 

src/Java.Interop/Tests/Java.Interop/JniTypeTest.cs

@@ -119,6 +119,25 @@ public void GetStaticFieldID ()
 			}
 		}
 
+		[Test]
+		public void Name ()
+		{
+			using (var Object_class         = new JniType ("java/lang/Object"))
+			using (var Class_class          = new JniType ("java/lang/Class"))
+			using (var Class_getMethod      = Class_class.GetInstanceMethod ("getMethod", "(Ljava/lang/String;[Ljava/lang/Class;)Ljava/lang/reflect/Method;"))
+			using (var Method_class         = new JniType ("java/lang/reflect/Method"))
+			using (var Method_getReturnType = Method_class.GetInstanceMethod ("getReturnType", "()Ljava/lang/Class;"))
+			using (var hashCode_str         = JniEnvironment.Strings.NewString ("hashCode"))
+			using (var Object_hashCode      = Class_getMethod.CallVirtualObjectMethod (Object_class.SafeHandle, new JValue (hashCode_str)))
+			using (var Object_hashCode_rt   = Method_getReturnType.CallVirtualObjectMethod (Object_hashCode))
+			{
+				Assert.AreEqual ("java/lang/Object", Object_class.Name);
+
+				using (var t = new JniType (Object_hashCode_rt, JniHandleOwnership.DoNotTransfer))
+					Assert.AreEqual ("I", t.Name);
+			}
+		}
+
 		[Test]
 		public void RegisterWithVM ()
 		{