[Java.Interop, generator] Fix Byte naming, support.

A funny thing happened while writing 959e14c: I saw that
JniBuiltinMarshalers.tt wasn't doing anything for java.lang.Byte!

(Quite an oversight! :-(

So I add an entry for "Byte", and it promptly breaks because of a
naming inconsistency: for most JNI marshal methods, I've been
following .NET convention -- CallInt64Method(), not CallLongMethod().
I failed to do so with respect to "byte", calling it Byte instead of
SByte (the Java `byte` type is signed, not unsigned).

(Interestingly I properly named JavaSByteArray. It's the JNI
Call*Method() names which are off!)

Add SByte marshaling to JniBuiltinMarshalers.tt so that values of type
java.lang.Byte and 'B' can be properly auto-marshaled.

Fixup generator to emit CallSByteMethod() methods instead of
CallByteMethod() methods.

Fixup all Call*ByteMethod() uses to be Call*SByteMethod() in the
public API, promoting consistency (and allowing the new SByte
auto-marshaler to actually compile).

Author: jonpryor

src/Java.Interop/Java.Interop/JniBuiltinMarshalers.cs

@@ -12,9 +12,10 @@ partial class JavaVM {
 			new KeyValuePair<Type, JniTypeInfo>(typeof (void),      new JniTypeInfo ("V",   typeIsKeyword: true)),
 			new KeyValuePair<Type, JniTypeInfo>(typeof (void),      new JniTypeInfo ("java/lang/Void")),
 
-			new KeyValuePair<Type, JniTypeInfo>(typeof (sbyte),     new JniTypeInfo ("B",   true)),
 			new KeyValuePair<Type, JniTypeInfo>(typeof (Boolean),  new JniTypeInfo ("Z", typeIsKeyword: true)),
 			new KeyValuePair<Type, JniTypeInfo>(typeof (Boolean),  new JniTypeInfo ("java/lang/Boolean")),
+			new KeyValuePair<Type, JniTypeInfo>(typeof (SByte),  new JniTypeInfo ("B", typeIsKeyword: true)),
+			new KeyValuePair<Type, JniTypeInfo>(typeof (SByte),  new JniTypeInfo ("java/lang/Byte")),
 			new KeyValuePair<Type, JniTypeInfo>(typeof (Char),  new JniTypeInfo ("C", typeIsKeyword: true)),
 			new KeyValuePair<Type, JniTypeInfo>(typeof (Char),  new JniTypeInfo ("java/lang/Character")),
 			new KeyValuePair<Type, JniTypeInfo>(typeof (Int16),  new JniTypeInfo ("S", typeIsKeyword: true)),
@@ -39,6 +40,11 @@ partial class JavaVM {
 				GetValueFromJni             = JniBoolean.GetValueFromJni,
 				CreateLocalRef              = JniBoolean.CreateLocalRef,
 			}),
+			new KeyValuePair<Type, JniMarshalInfo>(typeof (SByte), new JniMarshalInfo {
+				CreateJValue                = JniByte.CreateJValue,
+				GetValueFromJni             = JniByte.GetValueFromJni,
+				CreateLocalRef              = JniByte.CreateLocalRef,
+			}),
 			new KeyValuePair<Type, JniMarshalInfo>(typeof (Char), new JniMarshalInfo {
 				CreateJValue                = JniCharacter.CreateJValue,
 				GetValueFromJni             = JniCharacter.GetValueFromJni,
@@ -106,6 +112,40 @@ internal static object GetValueFromJni (JniReferenceSafeHandle self, JniHandleOw
 		}
 	}
 
+	static class JniByte {
+		internal    const   string  JniTypeName = "java/lang/Byte";
+
+		static JniType _TypeRef;
+		static JniType TypeRef {
+			get {return JniType.GetCachedJniType (ref _TypeRef, JniTypeName);}
+		}
+
+		internal static JValue CreateJValue (object value)
+		{
+			return new JValue ((SByte) value);
+		}
+
+		static JniInstanceMethodID init;
+		internal static JniLocalReference CreateLocalRef (object value)
+		{
+			Debug.Assert (value is SByte, "Expected value of type `SByte`; was: " + (value == null ? "<null>" : value.GetType ().FullName));
+			TypeRef.GetCachedConstructor (ref init, "(B)V");
+			return TypeRef.NewObject (init, new JValue ((SByte) value));
+		}
+
+		static JniInstanceMethodID byteValue;
+		internal static object GetValueFromJni (JniReferenceSafeHandle self, JniHandleOwnership transfer, Type targetType)
+		{
+			Debug.Assert (targetType == null || targetType == typeof (SByte), "Expected targetType==typeof(SByte); was: " + targetType);
+			TypeRef.GetCachedInstanceMethod (ref byteValue, "byteValue", "()B");
+			try {
+				return byteValue.CallVirtualSByteMethod (self);
+			} finally {
+				JniEnvironment.Handles.Dispose (self, transfer);
+			}
+		}
+	}
+
 	static class JniCharacter {
 		internal    const   string  JniTypeName = "java/lang/Character";
 

src/Java.Interop/Java.Interop/JniBuiltinMarshalers.tt

@@ -11,6 +11,7 @@ namespace Java.Interop {
 <#
 	var types = new[]{
 		new { Name = "Boolean",     Type = "Boolean",   JniType = "Z",  GetValue = "booleanValue" },
+		new { Name = "Byte",        Type = "SByte",     JniType = "B",  GetValue = "byteValue" },
 		new { Name = "Character",   Type = "Char",      JniType = "C",  GetValue = "charValue" },
 		new { Name = "Short",       Type = "Int16",     JniType = "S",  GetValue = "shortValue" },
 		new { Name = "Integer",     Type = "Int32",     JniType = "I",  GetValue = "intValue" },
@@ -28,7 +29,6 @@ namespace Java.Interop {
 			new KeyValuePair<Type, JniTypeInfo>(typeof (void),      new JniTypeInfo ("V",   typeIsKeyword: true)),
 			new KeyValuePair<Type, JniTypeInfo>(typeof (void),      new JniTypeInfo ("java/lang/Void")),
 
-			new KeyValuePair<Type, JniTypeInfo>(typeof (sbyte),     new JniTypeInfo ("B",   true)),
 <#
 	foreach (var type in types) {
 #>

src/Java.Interop/Java.Interop/JniInstanceMethodID.cs

@@ -39,14 +39,14 @@ public bool CallVirtualBooleanMethod (JniReferenceSafeHandle @this, params JValu
 			return JniEnvironment.Members.CallBooleanMethod (@this, this, parameters);
 		}
 
-		public sbyte CallVirtualByteMethod (JniReferenceSafeHandle @this)
+		public sbyte CallVirtualSByteMethod (JniReferenceSafeHandle @this)
 		{
-			return JniEnvironment.Members.CallByteMethod (@this, this);
+			return JniEnvironment.Members.CallSByteMethod (@this, this);
 		}
 
-		public sbyte CallVirtualByteMethod (JniReferenceSafeHandle @this, params JValue[] parameters)
+		public sbyte CallVirtualSByteMethod (JniReferenceSafeHandle @this, params JValue[] parameters)
 		{
-			return JniEnvironment.Members.CallByteMethod (@this, this, parameters);
+			return JniEnvironment.Members.CallSByteMethod (@this, this, parameters);
 		}
 
 		public char CallVirtualCharMethod (JniReferenceSafeHandle @this)
@@ -139,14 +139,14 @@ public bool CallNonvirtualBooleanMethod (JniReferenceSafeHandle @this, JniRefere
 			return JniEnvironment.Members.CallNonvirtualBooleanMethod (@this, declaringType, this, parameters);
 		}
 
-		public sbyte CallNonvirtualByteMethod (JniReferenceSafeHandle @this, JniReferenceSafeHandle declaringType)
+		public sbyte CallNonvirtualSByteMethod (JniReferenceSafeHandle @this, JniReferenceSafeHandle declaringType)
 		{
-			return JniEnvironment.Members.CallNonvirtualByteMethod (@this, declaringType, this);
+			return JniEnvironment.Members.CallNonvirtualSByteMethod (@this, declaringType, this);
 		}
 
-		public sbyte CallNonvirtualByteMethod (JniReferenceSafeHandle @this, JniReferenceSafeHandle declaringType, params JValue[] parameters)
+		public sbyte CallNonvirtualSByteMethod (JniReferenceSafeHandle @this, JniReferenceSafeHandle declaringType, params JValue[] parameters)
 		{
-			return JniEnvironment.Members.CallNonvirtualByteMethod (@this, declaringType, this, parameters);
+			return JniEnvironment.Members.CallNonvirtualSByteMethod (@this, declaringType, this, parameters);
 		}
 
 		public char CallNonvirtualCharMethod (JniReferenceSafeHandle @this, JniReferenceSafeHandle declaringType)