[generator] Phase 2: Kotlin @JvmInline value class projection

[jonathanpeppers]

Phase 2 of #1431. Builds on #1432 (sibling-collision dedup) by detecting Kotlin @JvmInline value class types in class-parse, surfacing them in api.xml, and projecting them into generator output as readonly struct wrappers — while JNI marshaling stays on the underlying primitive.

What this does

Given Kotlin source like:

@JvmInline
value class MyColor(val value: ULong)

object Widgets {
    fun tint(c: MyColor) { ... }
    fun pad(d: MyDp): MyDp { ... }
}

The generator now emits:

public readonly partial struct MyColor : System.IEquatable<MyColor> {
    public readonly long Value;
    public MyColor (long value) { Value = value; }
    public static implicit operator long (MyColor value) => value.Value;
    public static implicit operator MyColor (long value) => new MyColor (value);
    // == / != / Equals / GetHashCode / ToString
}

public static class Widgets {
    public static void Tint (MyColor c) { ... }   // was: void Tint (long c)
    public static MyDp Pad (MyDp d) { ... }       // was: long Pad (long d)
}

The bodies of Tint/Pad still pass the JVM-erased primitive (long) across JNI — the implicit conversion operators on the struct make that compile without any thunk changes.

Bytecode layer (commit 35ccc4f)

• New ClassFile.KotlinInlineClassUnderlyingJniType, MethodInfo.KotlinInlineClassReturnJniType, ParameterInfo.KotlinInlineClassJniType.
• KotlinFixups.Fixup does a pre-pass DetectInlineClasses that recognizes @JvmInline + KotlinClassFlags.IsInlineClass + a single non-synthetic instance field, then stamps each method's parameter/return JNI types when the Kotlin source-level type was an inline class.
• XmlClassDeclarationBuilder emits kotlin-inline-class, kotlin-inline-class-underlying-jni-type, kotlin-inline-class-jni-type (parameter), and kotlin-inline-class-return-jni-type (method) attributes.
• 4 new tests in KotlinInlineClassCollisionTests.

Generator layer (this commit)

• ClassGen.IsKotlinInlineClass / ClassGen.KotlinInlineClassUnderlyingJniType.
• Parameter.KotlinInlineClassJniType / Method.KotlinInlineClassReturnJniType.
• XmlApiImporter reads the new attributes.
• Parameter.Validate / ReturnValue.Validate apply the projection by looking up the wrapper ClassGen via SymbolTable and overriding managed_type so Type / FullName return the struct while Symbol (and therefore JNI marshaling) stays on the underlying primitive.
• New KotlinInlineClassStruct TypeWriter emits the wrapper struct.
• JavaInteropCodeGenerator.WriteType routes inline-class ClassGen instances to the new writer instead of BoundClass.
• New TypeNameUtilities.JniSignatureToJavaTypeName helper.
• 7 new unit tests in KotlinInlineClassTests.

Out of scope / known limitations

• Boxed inline-class positions (nullable like MyColor?, generics like List<MyColor>, supertype implementations) still emit Lcom/example/MyColor; references that no longer have a peer class binding. These were rare on the targeted Compose surface; users can unblock them via Metadata.xml (<remove-node>) until a follow-up.
• Reference-backed inline classes (e.g. value class Tag(val raw: String)) are detected as inline classes but the projection path expects a primitive backing field; non-primitive-backed inline classes are not yet projected.
• Generic inline classes (value class Wrap<T>(val v: T)).
• Validation against the Compose material3-android AAR is not part of this PR.

Tests

• Xamarin.Android.Tools.Bytecode-Tests: 82 passed, 0 failed (2 pre-existing skips).
• generator-Tests: 7 new tests pass; total matches baseline (432 passed; 23 failures are pre-existing environment issues unrelated to this change, confirmed by stashing the changes and re-running).

Closes part of #1431. Phase 1 (sibling-collision dedup) was #1432.

[Copilot]

Pull request overview

Adds Kotlin @JvmInline value class awareness end-to-end (bytecode → api.xml → generator) so inline-class parameters/returns can be projected as strongly-typed C# wrappers while preserving JNI marshaling on the JVM-erased underlying primitive.

Changes:

• Detect Kotlin inline/value classes in class-parse, stamp underlying JNI primitive info, and emit new inline-class attributes into api.xml.
• Import the new attributes in the generator and project method parameters/returns to inline-class wrapper types.
• Emit readonly partial struct wrapper types for inline classes and add unit tests covering import/projection/round-tripping.

Reviewed changes

Copilot reviewed 15 out of 15 changed files in this pull request and generated 8 comments.

Show a summary per file

File	Description
tools/generator/Utilities/TypeNameUtilities.cs	Adds helper to map JNI reference signatures to Java type names for symbol lookup.
tools/generator/SourceWriters/KotlinInlineClassStruct.cs	New type writer emitting the C# readonly struct wrapper for inline classes.
tools/generator/Java.Interop.Tools.Generator.ObjectModel/ReturnValue.cs	Projects return types to inline-class wrapper structs when stamped.
tools/generator/Java.Interop.Tools.Generator.ObjectModel/Parameter.cs	Projects parameter types to inline-class wrapper structs when stamped; preserves clone data.
tools/generator/Java.Interop.Tools.Generator.ObjectModel/Method.cs	Adds storage for stamped inline-class return JNI type.
tools/generator/Java.Interop.Tools.Generator.ObjectModel/ClassGen.cs	Adds inline-class flags/underlying descriptor to the object model.
tools/generator/Java.Interop.Tools.Generator.Importers/XmlApiImporter.cs	Reads new inline-class XML attributes into the generator model.
tools/generator/Java.Interop.Tools.Generator.CodeGeneration/JavaInteropCodeGenerator.cs	Routes inline classes to the new struct writer.
tests/Xamarin.Android.Tools.Bytecode-Tests/Xamarin.Android.Tools.Bytecode-Tests.targets	Adjusts embedded Kotlin fixture class list.
tests/Xamarin.Android.Tools.Bytecode-Tests/KotlinInlineClassCollisionTests.cs	Adds tests asserting fixup stamping and XML attribute emission.
tests/generator-Tests/Unit-Tests/KotlinInlineClassTests.cs	Adds tests covering XML import and the new helper.
src/Xamarin.Android.Tools.Bytecode/XmlClassDeclarationBuilder.cs	Emits new inline-class XML attributes for classes/methods/parameters.
src/Xamarin.Android.Tools.Bytecode/Methods.cs	Adds fields to carry stamped inline-class parameter/return JNI signatures.
src/Xamarin.Android.Tools.Bytecode/Kotlin/KotlinFixups.cs	Detects inline classes and stamps inline-class parameter/return metadata for projection.
src/Xamarin.Android.Tools.Bytecode/ClassFile.cs	Stores inline-class underlying JNI descriptor on the ClassFile.

[jonathanpeppers]

/review

[github-actions]

✅ Java.Interop PR Reviewer completed successfully!

[github-actions]

✅ LGTM — well-designed feature with minor issues

Summary: This PR adds Kotlin @JvmInline value class projection through the full pipeline (bytecode → api.xml → generator → C# wrapper structs). The architecture is clean — using the existing managedName attribute for name unmangling, projecting managed types while keeping JNI marshaling on primitives via the sym / managed_type split, and carefully filtering to only primitive-backed inline classes.

Issue counts:

• ⚠️ 2 warnings (silent fallback in JniPrimitiveToCSharpType; null-forgiving operator ! usage ×4)
• 💡 1 suggestion (klass2 naming)

Positive callouts:

• The two-pass approach in DetectInlineClasses (pre-scan all classes before processing methods) correctly handles cross-class references regardless of class ordering.
• Good defensive filtering: only primitive-backed inline classes are projected; reference-backed and boxed positions are explicitly excluded with clear documentation of why.
• The end-to-end test (KotlinInlineClassEndToEndTests) exercises the real Kotlin .class fixtures through the full pipeline — much stronger than testing against hand-crafted XML alone.
• Thorough comments linking each piece to the issue tracker (#1431) and explaining the "why" behind design decisions (e.g., why boxed positions are skipped).
• Method.Clone correctly copies KotlinInlineClassReturnJniType, and Parameter.Clone correctly copies KotlinInlineClassJniType.

CI: dotnet.java-interop is still queued/pending. license/cla passed.

Generated by Java.Interop PR Reviewer for issue #1440 · ● 10.6M