Generate null-safe Java code (#1692)

* As a result `JObject` can no longer have a `nullptr` reference.
* Add a series of `FooNullableType` accessible through `Foo.nullableType` which is equivalent to `Foo?` or `@Nullable Foo` in Java used in generic types and arrays.
* Add configuration options to add other custom annotations for nullable and non-nullable types.

Author: HosseinYousefi

.github/workflows/jnigen.yaml

@@ -46,9 +46,10 @@ jobs:
           channel: ${{ matrix.sdk }}
           cache: true
           cache-key: 'flutter-:os:-:channel:-:version:-:arch:-:hash:'
-      - uses: axel-op/googlejavaformat-action@fe78db8a90171b6a836449f8d0e982d5d71e5c5a
+      - uses: axel-op/googlejavaformat-action@0dc4ef525e7ed73d8dff50b1b062a4d441d014b5
         name: 'Check Java formatting with google-java-format'
         with:
+          version: 'v1.24.0'
           args: '--set-exit-if-changed'
       - id: install
         name: Install dependencies
@@ -136,9 +137,10 @@ jobs:
         with:
           distribution: 'zulu'
           java-version: '17'
-      - uses: axel-op/googlejavaformat-action@fe78db8a90171b6a836449f8d0e982d5d71e5c5a
+      - uses: axel-op/googlejavaformat-action@0dc4ef525e7ed73d8dff50b1b062a4d441d014b5
         name: 'Check Java formatting with google-java-format'
         with:
+          version: 'v1.24.0'
           args: '--set-exit-if-changed'
       - name: install clang tools & CMake
         run: |

pkgs/jni/CHANGELOG.md

@@ -1,6 +1,10 @@
+## 0.13.0-wip
+
+- Added nullable type classes for all Java objects.
+
 ## 0.12.2
 
-- Add `JniUtils.fromReferenceAddress` which helps with sending `JObject`s
+- Added `JniUtils.fromReferenceAddress` which helps with sending `JObject`s
   through method channels. You can send the address of the pointer as `long` and
   reconstruct the class using the helper method.
 - Fixed a bug where it would be possible for a type class inference to fail.

pkgs/jni/lib/jni_symbols.yaml

@@ -4,71 +4,86 @@ files:
     'java.lang.Object':
       name: JObject
       type_class: JObjectType
+      nullable_type_class: JObjectNullableType
       super_count: 0
     'java.lang.String':
       name: JString
       type_class: JStringType
+      nullable_type_class: JStringNullableType
       super_count: 1
     'java.lang.Number':
       name: JNumber
       type_class: JNumberType
+      nullable_type_class: JNumberNullableType
       super_count: 1
     'java.lang.Byte':
       name: JByte
       type_class: JByteType
+      nullable_type_class: JByteNullableType
       super_count: 2
     'java.lang.Short':
       name: JShort
       type_class: JShortType
+      nullable_type_class: JShortNullableType
       super_count: 2
     'java.lang.Integer':
       name: JInteger
       type_class: JIntegerType
+      nullable_type_class: JIntegerNullableType
       super_count: 2
     'java.lang.Long':
       name: JLong
       type_class: JLongType
+      nullable_type_class: JLongNullableType
       super_count: 2
     'java.lang.Float':
       name: JFloat
       type_class: JFloatType
+      nullable_type_class: JFloatNullableType
       super_count: 2
     'java.lang.Double':
       name: JDouble
       type_class: JDoubleType
+      nullable_type_class: JDoubleNullableType
       super_count: 2
     'java.lang.Boolean':
       name: JBoolean
       type_class: JBooleanType
+      nullable_type_class: JBooleanNullableType
       super_count: 1
     'java.lang.Character':
       name: JCharacter
       type_class: JCharacterType
+      nullable_type_class: JCharacterNullableType
       super_count: 1
     'java.util.Set':
       name: JSet
       type_class: JSetType
+      nullable_type_class: JSetNullableType
       super_count: 1
       type_params:
         E:
           'java.lang.Object': DECLARED
     'java.util.List':
       name: JList
       type_class: JListType
+      nullable_type_class: JListNullableType
       super_count: 1
       type_params:
         E:
           'java.lang.Object': DECLARED
     'java.util.Iterator':
       name: JIterator
       type_class: JIteratorType
+      nullable_type_class: JIteratorNullableType
       super_count: 1
       type_params:
         E:
           'java.lang.Object': DECLARED
     'java.util.Map':
       name: JMap
       type_class: JMapType
+      nullable_type_class: JMapNullableType
       super_count: 1
       type_params:
         K:
@@ -78,8 +93,10 @@ files:
     'java.nio.Buffer':
       name: JBuffer
       type_class: JBufferType
+      nullable_type_class: JBufferNullableType
       super_count: 1
     'java.nio.ByteBuffer':
       name: JByteBuffer
       type_class: JByteBufferType
+      nullable_type_class: JByteBufferNullableType
       super_count: 2

pkgs/jni/lib/src/accessors.dart

@@ -67,7 +67,7 @@ extension JniResultMethods on JniResult {
     return pointer == nullptr ? jNullReference : JGlobalReference(pointer);
   }
 
-  T object<T extends JObject>(JObjType<T> type) {
+  T object<T extends JObject?>(JObjType<T> type) {
     return type.fromReference(reference);
   }
 

pkgs/jni/lib/src/jarray.dart

@@ -6,6 +6,45 @@
 
 part of 'types.dart';
 
+final class JArrayNullableType<E> extends JObjType<JArray<E>?> {
+  @internal
+  final JArrayElementType<E> elementType;
+
+  @internal
+  const JArrayNullableType(this.elementType);
+
+  @internal
+  @override
+  String get signature => '[${elementType.signature}';
+
+  @internal
+  @override
+  JArray<E>? fromReference(JReference reference) =>
+      reference.isNull ? null : JArray.fromReference(elementType, reference);
+
+  @internal
+  @override
+  JObjType get superType => const JObjectNullableType();
+
+  @internal
+  @override
+  JObjType<JArray<E>?> get nullableType => this;
+
+  @internal
+  @override
+  final int superCount = 1;
+
+  @override
+  int get hashCode => Object.hash(JArrayNullableType, elementType);
+
+  @override
+  bool operator ==(Object other) {
+    return other.runtimeType == (JArrayNullableType<E>) &&
+        other is JArrayNullableType<E> &&
+        elementType == other.elementType;
+  }
+}
+
 final class JArrayType<E> extends JObjType<JArray<E>> {
   @internal
   final JArrayElementType<E> elementType;
@@ -26,6 +65,10 @@ final class JArrayType<E> extends JObjType<JArray<E>> {
   @override
   JObjType get superType => const JObjectType();
 
+  @internal
+  @override
+  JObjType<JArray<E>?> get nullableType => JArrayNullableType<E>(elementType);
+
   @internal
   @override
   final int superCount = 1;
@@ -53,6 +96,11 @@ class JArray<E> extends JObject {
   static JArrayType<E> type<E>(JArrayElementType<E> innerType) =>
       JArrayType(innerType);
 
+  /// The type which includes information such as the signature of this class.
+  static JArrayNullableType<E> nullableType<E>(
+          JArrayElementType<E> innerType) =>
+      JArrayNullableType(innerType);
+
   /// Construct a new [JArray] with [reference] as its underlying reference.
   JArray.fromReference(this.elementType, JReference reference)
       : $type = type(elementType),
@@ -61,7 +109,16 @@ class JArray<E> extends JObject {
   /// Creates a [JArray] of the given length from the given [elementType].
   ///
   /// The [length] must be a non-negative integer.
+  /// For objects, [elementType] must be a nullable type as this constructor
+  /// initializes all elements with `null`.
   factory JArray(JArrayElementType<E> elementType, int length) {
+    RangeError.checkNotNegative(length);
+    if (elementType is JObjType<JObject?> &&
+        !(elementType as JObjType<JObject?>).isNullable) {
+      throw StateError('Element type of JArray must be nullable when '
+          'all elements with null\n\n'
+          'Try using .nullableType instead');
+    }
     return elementType._newArray(length);
   }
 
@@ -366,17 +423,21 @@ extension DoubleArray on JArray<jdouble> {
   }
 }
 
-extension ObjectArray<T extends JObject> on JArray<T> {
+extension ObjectArray<T extends JObject?> on JArray<T> {
   T operator [](int index) {
     RangeError.checkValidIndex(index, this);
-    return (elementType as JObjType<T>).fromReference(JGlobalReference(
-        Jni.env.GetObjectArrayElement(reference.pointer, index)));
+    final pointer = Jni.env.GetObjectArrayElement(reference.pointer, index);
+    if (pointer == nullptr) {
+      return null as T;
+    }
+    return (elementType as JObjType<T>)
+        .fromReference(JGlobalReference(pointer));
   }
 
   void operator []=(int index, T value) {
     RangeError.checkValidIndex(index, this);
-    Jni.env.SetObjectArrayElement(
-        reference.pointer, index, value.reference.pointer);
+    final valueRef = value?.reference ?? jNullReference;
+    Jni.env.SetObjectArrayElement(reference.pointer, index, valueRef.pointer);
   }
 
   void setRange(int start, int end, Iterable<T> iterable, [int skipCount = 0]) {