Merge pull request #2 from kdroidFilter/feat/flow-dataclass-support

Add Flow<DataClass> support to FFM bridge generator

Author: kdroidFilter

.github/workflows/check.yaml

@@ -43,7 +43,7 @@ jobs:
           sudo apt-get install -y libnotify-dev libglib2.0-dev libdbusmenu-glib-dev
 
       - name: Plugin tests
-        run: ./gradlew --project-dir plugin-build :plugin:check
+        run: ./gradlew --project-dir plugin-build :nucleusnativeaccess:check
 
       - name: Examples tests
         run: ./gradlew :examples:calculator:check :examples:systeminfo:check :examples:benchmark:check

README.md

@@ -121,9 +121,9 @@ No JNI. No annotations. No boilerplate. Just write Kotlin/Native and use it from
 
 ## What's supported
 
-### Types — test coverage (739 end-to-end FFM tests)
+### Types — test coverage (770+ end-to-end FFM tests)
 
-Every test compiles Kotlin/Native → `libcalculator.so` (200+ exported symbols) → loads via FFM `MethodHandle` → verifies on JVM. Zero mocks — all 739 tests cross the real native boundary. Includes 25 load tests (500K+ FFM calls), concurrent stress tests (10 threads), 53 suspend function tests with cancellation, and 23 Flow tests.
+Every test compiles Kotlin/Native → `libcalculator.so` (200+ exported symbols) → loads via FFM `MethodHandle` → verifies on JVM. Zero mocks — all 770+ tests cross the real native boundary. Includes 25 load tests (500K+ FFM calls), concurrent stress tests (10 threads), 53 suspend function tests with cancellation, and 50+ Flow tests (including `Flow<DataClass>`).
 
 | Feature | As param | As return | As property | CB param | CB return | Notes |
 |---------|----------|-----------|-------------|----------|-----------|-------|
@@ -150,7 +150,7 @@ Every test compiles Kotlin/Native → `libcalculator.so` (200+ exported symbols)
 | `Map<K, V>` | ✅ 12t | ✅ 12t | &mdash; | ✅ 2t | ✅ 2t | String→Int, Int→String, Int→Int, String→String + merge/empty |
 | `Map<K, V>?` | &mdash; | ✅ 4t | &mdash; | &mdash; | &mdash; | -1 count = null sentinel |
 | `(T) -> R` (lambda) | ✅ 15t | &mdash; | &mdash; | &mdash; | &mdash; | persistent `Arena.ofShared()` |
-| `Flow<T>` | &mdash; | ✅ 23t | &mdash; | &mdash; | &mdash; | `channelFlow` + 3 callbacks (onNext, onError, onComplete) |
+| `Flow<T>` | &mdash; | ✅ 50t+ | &mdash; | &mdash; | &mdash; | `channelFlow` + 3 callbacks (onNext, onError, onComplete), incl. `Flow<DataClass>` |
 
 ### Declarations
 
@@ -168,7 +168,7 @@ Every test compiles Kotlin/Native → `libcalculator.so` (200+ exported symbols)
 | Data classes (nativeMain) | ✅ | auto-generates JVM data class + field marshalling |
 | Data classes (commonMain) | ✅ | reuses existing JVM type, no proxy generated |
 | Suspend functions | ✅ | `suspendCancellableCoroutine` + bidirectional cancellation (53 tests) |
-| Flow&lt;T&gt; return | ✅ | `channelFlow` + onNext/onError/onComplete callbacks (23 tests) |
+| Flow&lt;T&gt; return | ✅ | `channelFlow` + onNext/onError/onComplete callbacks (50+ tests, incl. DataClass) |
 | Exception propagation | ✅ | `try/catch` wrapping, `KotlinNativeException` on JVM |
 | Object lifecycle | ✅ | `Cleaner` for GC + `close()` for explicit release |
 
@@ -213,7 +213,23 @@ calc.infiniteFlow().take(3).toList()     // [0, 1, 2] — auto-cancelled
 
 **Cancellation**: collecting only N elements (via `take`, `first`) automatically cancels the native Flow collection. Manual `Job.cancel()` also propagates.
 
-**Supported element types**: `Int`, `Long`, `Double`, `Float`, `Boolean`, `Byte`, `Short`, `String`, `enum class`, `Object`.
+**Supported element types**: `Int`, `Long`, `Double`, `Float`, `Boolean`, `Byte`, `Short`, `String`, `enum class`, `Object`, `data class` (including nested data classes).
+
+**Data class in Flow**: data classes are serialized element-by-element via `StableRef` + per-type reader bridges. Nested data classes (e.g. `Flow<Rect>` where `Rect` contains two `Point`) are fully supported.
+
+```kotlin
+// Kotlin/Native
+data class MemoryInfo(val totalMB: Long, val availableMB: Long)
+
+fun memoryFlow(intervalMs: Long = 1000L): Flow<MemoryInfo> = flow {
+    while (true) { emit(MemoryInfo(getTotalMemoryMB(), getAvailableMemoryMB())); delay(intervalMs) }
+}
+
+// JVM — transparent Flow<DataClass> collection
+desktop.memoryFlow(2000L).collect { info ->
+    println("${info.availableMB} MB / ${info.totalMB} MB")
+}
+```
 
 ### Callbacks & lambdas
 
@@ -427,7 +443,7 @@ The plugin auto-generates GraalVM reachability metadata under `META-INF/native-i
 
 - `reflect-config.json` &mdash; all generated proxy classes
 - `resource-config.json` &mdash; bundled native library resources
-- `reachability-metadata.json` &mdash; FFM foreign downcall descriptors, reflection, and resources
+- `reachability-metadata.json` &mdash; FFM foreign downcall + upcall descriptors, reflection, and resources
 
 For GraalVM native-image builds, the native `.so`/`.dylib` must be placed next to the executable (the plugin bundles it in the JAR for JVM, but native-image can't extract at runtime).
 
@@ -503,7 +519,7 @@ The repository includes two complete examples in [`examples/`](examples/):
 
 | Example | Description |
 |---------|-------------|
-| [`calculator/`](examples/calculator/) | Stateful Calculator class with 739 end-to-end tests: all types, callbacks, collections, suspend, Flow, nested classes, concurrency |
+| [`calculator/`](examples/calculator/) | Stateful Calculator class with 770+ end-to-end tests: all types, callbacks, collections, suspend, Flow (incl. DataClass), nested classes, concurrency |
 | [`systeminfo/`](examples/systeminfo/) | Linux system info (`/proc`, POSIX, `gethostname`) + native notifications via `libnotify` cinterop, with Compose Desktop UI |
 | [`benchmark/`](examples/benchmark/) | Performance benchmarks: native vs JVM (fibonacci, pi, sort, string, allocation, concurrent) |
 
@@ -512,7 +528,7 @@ Run them:
 ```bash
 ./gradlew :examples:calculator:run
 ./gradlew :examples:systeminfo:run
-./gradlew :examples:calculator:jvmTest    # 739 end-to-end FFM tests
+./gradlew :examples:calculator:jvmTest    # 770+ end-to-end FFM tests
 ./gradlew :examples:benchmark:jvmTest     # Performance benchmarks (native vs JVM)
 ```
 

examples/calculator/src/jvmTest/kotlin/com/example/calculator/CalculatorTest.kt

@@ -6187,4 +6187,289 @@ class CalculatorTest {
             assertEquals(5, received)
         }
     }
+
+    // ═══════════════════════════════════════════════════════════════════════════
+    // Flow<DataClass> tests
+    // ═══════════════════════════════════════════════════════════════════════════
+
+    // ── Flow<Point> ─────────────────────────────────────────────────────────
+
+    @Test fun `flow dc - pointFlow basic`() = runBlocking {
+        Calculator(0).use { calc ->
+            val points = calc.pointFlow(3).toList()
+            assertEquals(3, points.size)
+            assertEquals(Point(0, 0), points[0])
+            assertEquals(Point(1, 2), points[1])
+            assertEquals(Point(2, 4), points[2])
+        }
+    }
+
+    @Test fun `flow dc - pointFlow single`() = runBlocking {
+        Calculator(0).use { calc ->
+            val points = calc.pointFlow(1).toList()
+            assertEquals(listOf(Point(0, 0)), points)
+        }
+    }
+
+    @Test fun `flow dc - pointFlow empty`() = runBlocking {
+        Calculator(0).use { calc ->
+            assertEquals(emptyList<Point>(), calc.pointFlow(0).toList())
+        }
+    }
+
+    @Test fun `flow dc - emptyPointFlow`() = runBlocking {
+        Calculator(0).use { calc ->
+            assertEquals(emptyList<Point>(), calc.emptyPointFlow().toList())
+        }
+    }
+
+    @Test fun `flow dc - singlePointFlow`() = runBlocking {
+        Calculator(5).use { calc ->
+            val points = calc.singlePointFlow().toList()
+            assertEquals(listOf(Point(5, 10)), points)
+        }
+    }
+
+    @Test fun `flow dc - singlePointFlow zero`() = runBlocking {
+        Calculator(0).use { calc ->
+            assertEquals(listOf(Point(0, 0)), calc.singlePointFlow().toList())
+        }
+    }
+
+    @Test fun `flow dc - pointFlow large`() = runBlocking {
+        Calculator(0).use { calc ->
+            val points = calc.pointFlow(100).toList()
+            assertEquals(100, points.size)
+            assertEquals(Point(99, 198), points.last())
+        }
+    }
+
+    @Test fun `flow dc - pointFlow take first`() = runBlocking {
+        Calculator(0).use { calc ->
+            val first = calc.pointFlow(100).first()
+            assertEquals(Point(0, 0), first)
+        }
+    }
+
+    @Test fun `flow dc - pointFlow take 3`() = runBlocking {
+        Calculator(0).use { calc ->
+            val items = calc.pointFlow(100).take(3).toList()
+            assertEquals(3, items.size)
+            assertEquals(Point(2, 4), items[2])
+        }
+    }
+
+    // ── Flow<NamedValue> (String field) ─────────────────────────────────────
+
+    @Test fun `flow dc - namedValueFlow basic`() = runBlocking {
+        Calculator(10).use { calc ->
+            calc.label = "hello"
+            val items = calc.namedValueFlow().toList()
+            assertEquals(2, items.size)
+            assertEquals(NamedValue("hello", 10), items[0])
+            assertEquals(NamedValue("second", 20), items[1])
+        }
+    }
+
+    @Test fun `flow dc - namedValueFlow default label`() = runBlocking {
+        Calculator(7).use { calc ->
+            val items = calc.namedValueFlow().toList()
+            assertEquals("default", items[0].name)
+            assertEquals(7, items[0].value)
+        }
+    }
+
+    @Test fun `flow dc - namedValueFlow unicode`() = runBlocking {
+        Calculator(1).use { calc ->
+            calc.label = "Kotlin"
+            val items = calc.namedValueFlow().toList()
+            assertEquals("Kotlin", items[0].name)
+        }
+    }
+
+    // ── Flow<TaggedPoint> (nested DC + enum) ────────────────────────────────
+
+    @Test fun `flow dc - taggedPointFlow`() = runBlocking {
+        Calculator(5).use { calc ->
+            val items = calc.taggedPointFlow().toList()
+            assertEquals(Operation.entries.size, items.size)
+            items.forEachIndexed { i, tp ->
+                assertEquals(Point(5, 10), tp.point)
+                assertEquals(Operation.entries[i], tp.tag)
+            }
+        }
+    }
+
+    @Test fun `flow dc - taggedPointFlow zero accumulator`() = runBlocking {
+        Calculator(0).use { calc ->
+            val items = calc.taggedPointFlow().toList()
+            assertEquals(Operation.entries.size, items.size)
+            items.forEach { assertEquals(Point(0, 0), it.point) }
+        }
+    }
+
+    @Test fun `flow dc - taggedPointFlow negative`() = runBlocking {
+        Calculator(-3).use { calc ->
+            val items = calc.taggedPointFlow().toList()
+            assertEquals(Point(-3, -6), items[0].point)
+        }
+    }
+
+    // ── Flow<CalcResult> (common DC with String) ────────────────────────────
+
+    @Test fun `flow dc - calcResultFlow basic`() = runBlocking {
+        Calculator(10).use { calc ->
+            val items = calc.calcResultFlow(3).toList()
+            assertEquals(3, items.size)
+            assertEquals(CalcResult(10, "step_0"), items[0])
+            assertEquals(CalcResult(11, "step_1"), items[1])
+            assertEquals(CalcResult(12, "step_2"), items[2])
+        }
+    }
+
+    @Test fun `flow dc - calcResultFlow empty`() = runBlocking {
+        Calculator(0).use { calc ->
+            assertEquals(emptyList<CalcResult>(), calc.calcResultFlow(0).toList())
+        }
+    }
+
+    @Test fun `flow dc - calcResultFlow single`() = runBlocking {
+        Calculator(42).use { calc ->
+            val items = calc.calcResultFlow(1).toList()
+            assertEquals(listOf(CalcResult(42, "step_0")), items)
+        }
+    }
+
+    @Test fun `flow dc - calcResultFlow take`() = runBlocking {
+        Calculator(0).use { calc ->
+            val first = calc.calcResultFlow(50).first()
+            assertEquals(CalcResult(0, "step_0"), first)
+        }
+    }
+
+    // ── Flow<Rect> (deeply nested DC) ───────────────────────────────────────
+
+    @Test fun `flow dc - rectFlow basic`() = runBlocking {
+        Calculator(10).use { calc ->
+            val items = calc.rectFlow().toList()
+            assertEquals(2, items.size)
+            assertEquals(Rect(Point(0, 0), Point(10, 10)), items[0])
+            assertEquals(Rect(Point(1, 1), Point(11, 11)), items[1])
+        }
+    }
+
+    @Test fun `flow dc - rectFlow zero`() = runBlocking {
+        Calculator(0).use { calc ->
+            val items = calc.rectFlow().toList()
+            assertEquals(Rect(Point(0, 0), Point(0, 0)), items[0])
+        }
+    }
+
+    @Test fun `flow dc - rectFlow negative`() = runBlocking {
+        Calculator(-5).use { calc ->
+            val items = calc.rectFlow().toList()
+            assertEquals(Rect(Point(0, 0), Point(-5, -5)), items[0])
+            assertEquals(Rect(Point(1, 1), Point(-4, -4)), items[1])
+        }
+    }
+
+    // ── Flow<DC> error handling ─────────────────────────────────────────────
+
+    @Test fun `flow dc - failingPointFlow throws after first`() = runBlocking {
+        Calculator(0).use { calc ->
+            val items = mutableListOf<Point>()
+            assertFailsWith<KotlinNativeException> {
+                calc.failingPointFlow().collect { items.add(it) }
+            }
+            assertEquals(listOf(Point(1, 2)), items)
+        }
+    }
+
+    // ── Flow<DC> concurrency ────────────────────────────────────────────────
+
+    @Test fun `flow dc - 5 concurrent pointFlow`() = runBlocking {
+        Calculator(1).use { calc ->
+            val results = (1..5).map { async(Dispatchers.Default) {
+                calc.pointFlow(5).toList()
+            } }.awaitAll()
+            assertEquals(5, results.size)
+            results.forEach { points ->
+                assertEquals(5, points.size)
+                assertEquals(Point(0, 0), points[0])
+            }
+        }
+    }
+
+    @Test fun `flow dc - concurrent on separate instances`() = runBlocking {
+        val results = (1..10).map { i ->
+            async(Dispatchers.Default) {
+                Calculator(i).use { calc -> calc.singlePointFlow().toList() }
+            }
+        }.awaitAll()
+        results.forEachIndexed { i, points ->
+            assertEquals(1, points.size)
+            assertEquals(Point(i + 1, (i + 1) * 2), points[0])
+        }
+    }
+
+    // ── Flow<DC> sequential stress ──────────────────────────────────────────
+
+    @Test fun `flow dc - 50 sequential pointFlows`() = runBlocking {
+        Calculator(0).use { calc ->
+            repeat(50) {
+                val points = calc.pointFlow(3).toList()
+                assertEquals(3, points.size)
+            }
+        }
+    }
+
+    @Test fun `flow dc - pointFlow then sync methods`() = runBlocking {
+        Calculator(5).use { calc ->
+            val points = calc.pointFlow(3).toList()
+            assertEquals(3, points.size)
+            assertEquals(5, calc.current)
+            calc.add(10)
+            assertEquals(15, calc.current)
+        }
+    }
+
+    @Test fun `flow dc - pointFlow then suspend`() = runBlocking {
+        Calculator(0).use { calc ->
+            calc.pointFlow(2).toList()
+            val r = calc.delayedAdd(3, 4)
+            assertEquals(7, r)
+        }
+    }
+
+    @Test fun `flow dc - pointFlow then other flow types`() = runBlocking {
+        Calculator(5).use { calc ->
+            val points = calc.pointFlow(2).toList()
+            assertEquals(2, points.size)
+            val ints = calc.countUp(3).toList()
+            assertEquals(listOf(1, 2, 3), ints)
+            val results = calc.calcResultFlow(2).toList()
+            assertEquals(2, results.size)
+        }
+    }
+
+    @Test fun `flow dc - mix all dc flow types`() = runBlocking {
+        Calculator(3).use { calc ->
+            calc.label = "test"
+            val points = calc.pointFlow(2).toList()
+            val named = calc.namedValueFlow().toList()
+            val tagged = calc.taggedPointFlow().toList()
+            val results = calc.calcResultFlow(2).toList()
+            val rects = calc.rectFlow().toList()
+
+            assertEquals(2, points.size)
+            assertEquals(2, named.size)
+            assertEquals(Operation.entries.size, tagged.size)
+            assertEquals(2, results.size)
+            assertEquals(2, rects.size)
+
+            assertEquals("test", named[0].name)
+            assertEquals(Point(3, 6), tagged[0].point)
+            assertEquals(CalcResult(3, "step_0"), results[0])
+        }
+    }
 }