Fix boolean issue in Java bindings.

This is due to the fact that jni::sys::jboolean is just a typedef to u8.
When I was setting the the boolean value, I was using the JValue conversion.
It was converting it erroneously to a u8, not a boolean. The rest is just
the JVM having a very bad time with it.

Author: emgre

generators/java-oo-bindgen/src/rust/conversion.rs

@@ -431,7 +431,7 @@ impl TypeConverter for BooleanConverter {
     }
 
     fn convert_from_rust(&self, f: &mut dyn Printer, from: &str, to: &str) -> FormattingResult<()> {
-        f.writeln(&format!("{}if {} {{ 1 }} else {{ 0 }}", to, from))
+        f.writeln(&format!("{}{}", to, from))
     }
 }
 

generators/java-oo-bindgen/src/rust/mod.rs

@@ -329,7 +329,7 @@ fn generate_functions(
 
             // Return value
             if !handle.return_type.is_void() {
-                f.writeln("return _result;")?;
+                f.writeln("return _result.into();")?;
             }
 
             Ok(())

tests/bindings/java/foo-tests/src/test/java/io/stepfunc/foo_test/StructureTest.java

@@ -66,7 +66,10 @@ private static void checkStructure(Structure structure) {
         assertThat(structure.stringValue).isEqualTo("Hello");
 
         assertThat(structure.structureValue.test).isEqualTo(ushort(41));
+        assertThat(structure.structureValue.firstEnumValue).isEqualTo(StructureEnum.VAR2);
+        assertThat(structure.structureValue.secondEnumValue).isEqualTo(StructureEnum.VAR2);
         assertThat(structure.enumValue).isEqualTo(StructureEnum.VAR2);
+        assertThat(structure.enumValue2).isEqualTo(StructureEnum.VAR2);
 
         assertThat(structure.durationMillis).isEqualTo(Duration.ofMillis(4200));
         assertThat(structure.durationSeconds).isEqualTo(Duration.ofSeconds(76));

tests/foo-schema/src/structure.rs

@@ -5,13 +5,6 @@ use oo_bindgen::native_struct::StructElementType;
 use oo_bindgen::*;
 
 pub fn define(lib: &mut LibraryBuilder) -> Result<(), BindingError> {
-    let other_structure = lib.declare_native_struct("OtherStructure")?;
-    let other_structure = lib
-        .define_native_struct(&other_structure)?
-        .add("test", StructElementType::Uint16(Some(41)), "test")?
-        .doc("Structure within a structure")?
-        .build()?;
-
     let structure_enum = lib
         .define_native_enum("StructureEnum")?
         .push("Var1", "Var1")?
@@ -20,6 +13,26 @@ pub fn define(lib: &mut LibraryBuilder) -> Result<(), BindingError> {
         .doc("Enum")?
         .build()?;
 
+    let other_structure = lib.declare_native_struct("OtherStructure")?;
+    let other_structure = lib
+        .define_native_struct(&other_structure)?
+        .add("test", StructElementType::Uint16(Some(41)), "test")?
+        // The following pattern used to crash in Java because of the way we handled boolean
+        .add(
+            "first_enum_value",
+            StructElementType::Enum(structure_enum.clone(), Some("Var2".to_string())),
+            "first_enum_value",
+        )?
+        .add("bool1", StructElementType::Sint16(Some(1)), "bool1")?
+        .add("bool2", StructElementType::Bool(Some(false)), "bool2")?
+        .add(
+            "second_enum_value",
+            StructElementType::Enum(structure_enum.clone(), Some("Var2".to_string())),
+            "second_enum_value",
+        )?
+        .doc("Structure within a structure")?
+        .build()?;
+
     let structure = lib.declare_native_struct("Structure")?;
 
     let structure_interface = lib
@@ -33,11 +46,26 @@ pub fn define(lib: &mut LibraryBuilder) -> Result<(), BindingError> {
 
     let structure = lib
         .define_native_struct(&structure)?
+        .add(
+            "enum_value",
+            StructElementType::Enum(structure_enum.clone(), Some("Var2".to_string())),
+            "enum_value",
+        )?
         .add(
             "boolean_value",
             StructElementType::Bool(Some(true)),
             "boolean_value",
         )?
+        .add(
+            "boolean_value2",
+            StructElementType::Bool(Some(true)),
+            "boolean_value2",
+        )?
+        .add(
+            "enum_value2",
+            StructElementType::Enum(structure_enum, Some("Var2".to_string())),
+            "enum_value2",
+        )?
         .add(
             "uint8_value",
             StructElementType::Uint8(Some(1)),
@@ -98,11 +126,6 @@ pub fn define(lib: &mut LibraryBuilder) -> Result<(), BindingError> {
             Type::Struct(other_structure),
             "structure_value",
         )?
-        .add(
-            "enum_value",
-            StructElementType::Enum(structure_enum, Some("Var2".to_string())),
-            "enum_value",
-        )?
         .add(
             "interface_value",
             Type::Interface(structure_interface),