[jnigen] Support Kotlin operators (#1969)

Author: HosseinYousefi

pkgs/jnigen/CHANGELOG.md

@@ -1,3 +1,6 @@
+## 0.14.1-wip
+- Added support for generating matching Kotlin operators as Dart operators.
+
 ## 0.14.0
 
 - Fixed a bug where the source parser would not have all of the type paremeters

pkgs/jnigen/java/src/main/java/com/github/dart_lang/jnigen/apisummarizer/elements/KotlinFunction.java

@@ -26,6 +26,7 @@ public class KotlinFunction {
   public List<KotlinTypeParameter> typeParameters;
   public int flags;
   public boolean isSuspend;
+  public boolean isOperator;
 
   public static KotlinFunction fromKmFunction(KmFunction f) {
     var fun = new KotlinFunction();
@@ -36,6 +37,7 @@ public static KotlinFunction fromKmFunction(KmFunction f) {
     fun.flags = f.getFlags();
     // Processing the information needed from the flags.
     fun.isSuspend = Flag.Function.IS_SUSPEND.invoke(fun.flags);
+    fun.isOperator = Flag.Function.IS_OPERATOR.invoke(fun.flags);
     fun.valueParameters =
         f.getValueParameters().stream()
             .map(KotlinValueParameter::fromKmValueParameter)

pkgs/jnigen/lib/src/bindings/dart_generator.dart

@@ -432,6 +432,13 @@ class $name$typeParamsDef extends $superName {
     // Fields and Methods
     generateFieldsAndMethods(node, classRef);
 
+    // Operators
+    for (final MapEntry(key: operator, value: method)
+        in node.operators.entries) {
+      method.accept(_OperatorGenerator(resolver, s, operator: operator));
+    }
+    node.compareTo?.accept(_ComparatorGenerator(resolver, s));
+
     if (node.declKind == DeclKind.interfaceKind) {
       s.write('''
   /// Maps a specific port to the implemented interface.
@@ -1970,3 +1977,56 @@ class _CallMethodName extends Visitor<Method, String> {
     return 'globalEnv_Call${node.isStatic ? 'Static' : ''}${type}Method';
   }
 }
+
+class _OperatorGenerator extends Visitor<Method, void> {
+  final Resolver resolver;
+  final StringSink s;
+  final Operator operator;
+
+  _OperatorGenerator(this.resolver, this.s, {required this.operator});
+
+  @override
+  void visit(Method node) {
+    final returnType = operator.returnsVoid
+        ? 'void'
+        : node.returnType.accept(_TypeGenerator(resolver));
+    final paramsDef = node.params.accept(_ParamDef(resolver)).join(', ');
+    final paramsCall = node.params.map((param) => param.finalName).join(', ');
+    s.write('''
+  $returnType operator ${operator.dartSymbol}($paramsDef) {
+    ${operator.returnsVoid ? '' : 'return '}${node.finalName}($paramsCall);
+  }
+''');
+  }
+}
+
+class _ComparatorGenerator extends Visitor<Method, void> {
+  final Resolver resolver;
+  final StringSink s;
+
+  _ComparatorGenerator(this.resolver, this.s);
+
+  @override
+  void visit(Method node) {
+    final paramsDef = node.params.accept(_ParamDef(resolver)).join(', ');
+    final paramsCall = node.params.map((param) => param.finalName).join(', ');
+    final name = node.finalName;
+    s.write('''
+  bool operator <($paramsDef) {
+    return $name($paramsCall) < 0;
+  }
+
+  bool operator <=($paramsDef) {
+    return $name($paramsCall) <= 0;
+  }
+
+  bool operator >($paramsDef) {
+    return $name($paramsCall) > 0;
+  }
+
+  bool operator >=($paramsDef) {
+    return $name($paramsCall) >= 0;
+  }
+''');
+  }
+}

pkgs/jnigen/lib/src/bindings/kotlin_processor.dart

@@ -136,6 +136,7 @@ class _KotlinMethodProcessor extends Visitor<Method, void> {
   @override
   void visit(Method node) {
     _processParams(node.params, function.valueParameters);
+    node.kotlinFunction = function;
     for (var i = 0; i < node.typeParams.length; ++i) {
       node.typeParams[i]
           .accept(_KotlinTypeParamProcessor(function.typeParameters[i]));

pkgs/jnigen/lib/src/bindings/linker.dart

@@ -221,6 +221,24 @@ class _MethodLinker extends Visitor<Method, void> {
       param.method = node;
     }
     node.asyncReturnType?.accept(typeLinker);
+    // Fill out operator overloadings.
+    if (node.kotlinFunction?.isOperator ?? false) {
+      if (Operator.values.asNameMap()[node.kotlinFunction!.name]
+          case final operatorKind? when operatorKind.isCompatibleWith(node)) {
+        node.classDecl.operators[operatorKind] ??= node;
+      }
+    }
+    // Fill out compareTo method of the class used for comparison operators.
+    if (node.name == 'compareTo' && node.params.length == 1) {
+      final returnType = node.returnType.type;
+      final parameterType = node.params.single.type.type;
+      if (parameterType is DeclaredType &&
+          parameterType.binaryName == node.classDecl.binaryName &&
+          returnType is PrimitiveType &&
+          returnType.dartType == 'int') {
+        node.classDecl.compareTo = node;
+      }
+    }
   }
 }
 

pkgs/jnigen/lib/src/elements/elements.dart

@@ -165,6 +165,21 @@ class ClassDecl with ClassMember, Annotated implements Element<ClassDecl> {
   @JsonKey(includeFromJson: false)
   late final Map<String, int> methodNumsAfterRenaming;
 
+  /// Populated by [Linker].
+  @JsonKey(includeFromJson: false)
+  final Map<Operator, Method> operators = {};
+
+  /// The `compareTo` method of this class.
+  ///
+  /// This method must take a single parameter of the same type of the enclosing
+  /// class, and return integer.
+  ///
+  /// Used for overloading comparison operators.
+  ///
+  /// Populated by [Linker].
+  @JsonKey(includeFromJson: false)
+  Method? compareTo;
+
   @override
   String toString() {
     return 'Java class declaration for $binaryName';
@@ -682,8 +697,9 @@ class Method with ClassMember, Annotated implements Element<Method> {
   @override
   late String finalName;
 
+  /// Populated by [KotlinProcessor].
   @JsonKey(includeFromJson: false)
-  late bool isOverridden;
+  KotlinFunction? kotlinFunction;
 
   /// The actual return type when the method is a Kotlin's suspend fun.
   ///
@@ -1040,6 +1056,7 @@ class KotlinFunction {
     this.typeParameters = const [],
     required this.flags,
     required this.isSuspend,
+    required this.isOperator,
   });
 
   /// Name in the byte code.
@@ -1056,6 +1073,7 @@ class KotlinFunction {
   final List<KotlinTypeParameter> typeParameters;
   final int flags;
   final bool isSuspend;
+  final bool isOperator;
 
   factory KotlinFunction.fromJson(Map<String, dynamic> json) =>
       _$KotlinFunctionFromJson(json);
@@ -1251,3 +1269,31 @@ class KotlinTypeProjection extends KotlinTypeArgument {
   final KotlinType type;
   final KmVariance variance;
 }
+
+enum Operator {
+  plus('+', parameterCount: 1),
+  minus('-', parameterCount: 1),
+  times('*', parameterCount: 1),
+  div('/', parameterCount: 1),
+  rem('%', parameterCount: 1),
+  get('[]', parameterCount: 1),
+  set('[]=', parameterCount: 2, returnsVoid: true);
+
+  final String dartSymbol;
+
+  /// The number of parameters this operator must have in Dart.
+  final int parameterCount;
+
+  /// Whether the return type that this operator must have in Dart is void.
+  final bool returnsVoid;
+
+  const Operator(
+    this.dartSymbol, {
+    required this.parameterCount,
+    this.returnsVoid = false,
+  });
+
+  bool isCompatibleWith(Method method) {
+    return parameterCount == method.params.length;
+  }
+}

pkgs/jnigen/lib/src/elements/elements.g.dart

@@ -4,7 +4,7 @@
 
 name: jnigen
 description: A Dart bindings generator for Java and Kotlin that uses JNI under the hood to interop with Java virtual machine.
-version: 0.14.0
+version: 0.14.1-wip
 repository: https://github.com/dart-lang/native/tree/main/pkgs/jnigen
 issue_tracker: https://github.com/dart-lang/native/issues?q=is%3Aissue+is%3Aopen+label%3Apackage%3Ajnigen