fix(nitrogen): match Kotlin's is prefix rule for JVM accessors

Kotlin only shortens a property's JVM accessor names when `is` is not
followed by a lowercase letter, and it applies that rule to every type,
not just booleans (`JvmAbi.startsWithIsPrefix`). Nitrogen used a plain
`startsWith('is')` check that was additionally gated on the property
being a boolean, so for names such as `isolatedBoolean` or for a
non-boolean `isTextValue` it generated JNI lookups for methods the
Kotlin class does not expose, crashing at runtime on Android.

Also covers the two shapes with `isolatedBoolean` and `isTextValue` on
`SharedTestObjectProps` plus assertions in `getTests.ts`.

Author: giaBaoJS

example/src/getTests.ts

@@ -551,6 +551,22 @@ export function getTests(
         .didNotThrow()
         .equals(true)
     ),
+    createTest('set + get isolatedBoolean', () =>
+      it(() => {
+        testObject.isolatedBoolean = true
+        return testObject.isolatedBoolean
+      })
+        .didNotThrow()
+        .equals(true)
+    ),
+    createTest('set + get isTextValue', () =>
+      it(() => {
+        testObject.isTextValue = 'hello'
+        return testObject.isTextValue
+      })
+        .didNotThrow()
+        .equals('hello')
+    ),
     createTest('set optionalCallback, then undefined', () =>
       it(() => {
         testObject.optionalCallback = () => {}

packages/nitrogen/src/syntax/Property.ts

@@ -14,6 +14,14 @@ export interface PropertyBody {
 
 export type LanguageEnvironment = 'jvm' | 'swift' | 'other'
 
+// Kotlin only shortens accessors when `is` is not followed by a lowercase letter
+// (see `JvmAbi.startsWithIsPrefix`), and it does that for every type - not just booleans.
+function hasJvmIsPrefix(name: string): boolean {
+  if (!name.startsWith('is') || name.length === 2) return false
+  const next = name.charAt(2)
+  return next < 'a' || next > 'z'
+}
+
 export interface PropertyModifiers {
   /**
    * The name of the class that defines this C++ property getter/setter method.
@@ -72,49 +80,34 @@ export class Property implements CodeNode {
   }
 
   getGetterName(environment: LanguageEnvironment): string {
-    if (this.type.kind === 'boolean') {
-      // Boolean accessors where the property starts with "is" or "has" are renamed in JVM and Swift
-      switch (environment) {
-        case 'jvm':
-          if (this.name.startsWith('is')) {
-            // isSomething -> isSomething()
-            return this.name
-          } else {
-            break
-          }
-        case 'swift':
-          if (this.name.startsWith('is')) {
-            // isSomething -> isSomething()
-            return this.name
-          } else if (this.name.startsWith('has')) {
-            // hasSomething -> hasSomething()
-            return this.name
-          } else {
-            break
-          }
-        default:
-          break
-      }
+    switch (environment) {
+      case 'jvm':
+        if (hasJvmIsPrefix(this.name)) {
+          // isSomething -> isSomething()
+          return this.name
+        }
+        break
+      case 'swift':
+        // Swift only shortens boolean accessors that start with "is" or "has"
+        if (
+          this.type.kind === 'boolean' &&
+          (this.name.startsWith('is') || this.name.startsWith('has'))
+        ) {
+          // isSomething -> isSomething()
+          return this.name
+        }
+        break
+      default:
+        break
     }
     // isSomething -> getIsSomething()
     return `get${capitalizeName(this.name)}`
   }
 
   getSetterName(environment: LanguageEnvironment): string {
-    if (this.type.kind === 'boolean') {
-      // Boolean accessors where the property starts with "is" are renamed in JVM
-      switch (environment) {
-        case 'jvm':
-          if (this.name.startsWith('is')) {
-            // isSomething -> setSomething()
-            const cleanName = this.name.replace('is', '')
-            return `set${capitalizeName(cleanName)}`
-          } else {
-            break
-          }
-        default:
-          break
-      }
+    if (environment === 'jvm' && hasJvmIsPrefix(this.name)) {
+      // isSomething -> setSomething()
+      return `set${capitalizeName(this.name.slice(2))}`
     }
     // isSomething -> setIsSomething()
     return `set${capitalizeName(this.name)}`

packages/react-native-nitro-test/android/src/main/java/com/margelo/nitro/test/HybridTestObjectKotlin.kt

@@ -43,6 +43,8 @@ class HybridTestObjectKotlin : HybridTestObjectSwiftKotlinSpec() {
   override val isBoolean = false
   override var hasBooleanWritable = false
   override var isBooleanWritable = false
+  override var isolatedBoolean = false
+  override var isTextValue = ""
 
   override fun simpleFunc() {
     // do nothing

packages/react-native-nitro-test/cpp/HybridTestObjectCpp.cpp

@@ -183,6 +183,22 @@ void HybridTestObjectCpp::setHasBooleanWritable(bool hasBooleanWritable) {
   _hasBooleanWritable = hasBooleanWritable;
 }
 
+bool HybridTestObjectCpp::getIsolatedBoolean() {
+  return _isolatedBoolean;
+}
+
+void HybridTestObjectCpp::setIsolatedBoolean(bool isolatedBoolean) {
+  _isolatedBoolean = isolatedBoolean;
+}
+
+std::string HybridTestObjectCpp::getIsTextValue() {
+  return _isTextValue;
+}
+
+void HybridTestObjectCpp::setIsTextValue(const std::string& isTextValue) {
+  _isTextValue = isTextValue;
+}
+
 void HybridTestObjectCpp::setOptionalCallback(const std::optional<std::function<void(double)>>& callback) {
   _optionalCallback = callback;
 }

packages/react-native-nitro-test/cpp/HybridTestObjectCpp.hpp

@@ -45,6 +45,8 @@ class HybridTestObjectCpp : public HybridTestObjectCppSpec {
   std::optional<std::function<void(double)>> _optionalCallback;
   bool _hasBooleanWritable;
   bool _isBooleanWritable;
+  bool _isolatedBoolean;
+  std::string _isTextValue;
 
 private:
   static inline uint64_t calculateFibonacci(int count) noexcept {
@@ -103,6 +105,10 @@ class HybridTestObjectCpp : public HybridTestObjectCppSpec {
   void setIsBooleanWritable(bool isBooleanWritable) override;
   bool getHasBooleanWritable() override;
   void setHasBooleanWritable(bool hasBooleanWritable) override;
+  bool getIsolatedBoolean() override;
+  void setIsolatedBoolean(bool isolatedBoolean) override;
+  std::string getIsTextValue() override;
+  void setIsTextValue(const std::string& isTextValue) override;
 
 public:
   // Methods

packages/react-native-nitro-test/ios/HybridTestObjectSwift.swift

@@ -49,6 +49,8 @@ class HybridTestObjectSwift: HybridTestObjectSwiftKotlinSpec {
   let isBoolean = false
   var hasBooleanWritable = false
   var isBooleanWritable = false
+  var isolatedBoolean = false
+  var isTextValue = ""
 
   var thisObject: any HybridTestObjectSwiftKotlinSpec {
     return self

packages/react-native-nitro-test/nitrogen/generated/android/c++/JHybridTestObjectSwiftKotlinSpec.cpp

@@ -364,6 +364,24 @@ namespace margelo::nitro::test {
     static const auto method = _javaPart->javaClassStatic()->getMethod<void(jboolean /* isBooleanWritable */)>("setBooleanWritable");
     method(_javaPart, isBooleanWritable);
   }
+  bool JHybridTestObjectSwiftKotlinSpec::getIsolatedBoolean() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jboolean()>("getIsolatedBoolean");
+    auto __result = method(_javaPart);
+    return static_cast<bool>(__result);
+  }
+  void JHybridTestObjectSwiftKotlinSpec::setIsolatedBoolean(bool isolatedBoolean) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jboolean /* isolatedBoolean */)>("setIsolatedBoolean");
+    method(_javaPart, isolatedBoolean);
+  }
+  std::string JHybridTestObjectSwiftKotlinSpec::getIsTextValue() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<jni::JString>()>("isTextValue");
+    auto __result = method(_javaPart);
+    return __result->toStdString();
+  }
+  void JHybridTestObjectSwiftKotlinSpec::setIsTextValue(const std::string& isTextValue) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* isTextValue */)>("setTextValue");
+    method(_javaPart, jni::make_jstring(isTextValue));
+  }
   std::variant<double, std::string> JHybridTestObjectSwiftKotlinSpec::getSomeVariant() {
     static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JVariant_Double_String>()>("getSomeVariant");
     auto __result = method(_javaPart);

packages/react-native-nitro-test/nitrogen/generated/android/c++/JHybridTestObjectSwiftKotlinSpec.hpp

@@ -87,6 +87,10 @@ namespace margelo::nitro::test {
     void setHasBooleanWritable(bool hasBooleanWritable) override;
     bool getIsBooleanWritable() override;
     void setIsBooleanWritable(bool isBooleanWritable) override;
+    bool getIsolatedBoolean() override;
+    void setIsolatedBoolean(bool isolatedBoolean) override;
+    std::string getIsTextValue() override;
+    void setIsTextValue(const std::string& isTextValue) override;
     std::variant<double, std::string> getSomeVariant() override;
     void setSomeVariant(const std::variant<double, std::string>& someVariant) override;
 

packages/react-native-nitro-test/nitrogen/generated/android/kotlin/com/margelo/nitro/test/HybridTestObjectSwiftKotlinSpec.kt

@@ -161,6 +161,18 @@ abstract class HybridTestObjectSwiftKotlinSpec: HybridObject() {
   @set:Keep
   abstract var isBooleanWritable: Boolean
 
+  @get:DoNotStrip
+  @get:Keep
+  @set:DoNotStrip
+  @set:Keep
+  abstract var isolatedBoolean: Boolean
+  
+  @get:DoNotStrip
+  @get:Keep
+  @set:DoNotStrip
+  @set:Keep
+  abstract var isTextValue: String
+  
   @get:DoNotStrip
   @get:Keep
   @set:DoNotStrip

packages/react-native-nitro-test/nitrogen/generated/ios/c++/HybridTestObjectSwiftKotlinSpecSwift.hpp

@@ -262,6 +262,19 @@ namespace margelo::nitro::test {
     inline void setIsBooleanWritable(bool isBooleanWritable) noexcept override {
       _swiftPart.setIsBooleanWritable(std::forward<decltype(isBooleanWritable)>(isBooleanWritable));
     }
+    inline bool getIsolatedBoolean() noexcept override {
+      return _swiftPart.isolatedBoolean();
+    }
+    inline void setIsolatedBoolean(bool isolatedBoolean) noexcept override {
+      _swiftPart.setIsolatedBoolean(std::forward<decltype(isolatedBoolean)>(isolatedBoolean));
+    }
+    inline std::string getIsTextValue() noexcept override {
+      auto __result = _swiftPart.getIsTextValue();
+      return __result;
+    }
+    inline void setIsTextValue(const std::string& isTextValue) noexcept override {
+      _swiftPart.setIsTextValue(isTextValue);
+    }
     inline std::variant<double, std::string> getSomeVariant() noexcept override {
       auto __result = _swiftPart.getSomeVariant();
       return __result;