Add UCO-specific JniSignatureHelper methods and tests

Add JniParamKind enum, ParseParameterTypes, ParseReturnType,
EncodeClrType, ParseSingleType, and their test classes
(JniSignatureHelperTests, NegativeEdgeCase) — moved from PR #10808.

Also add back JavaConstructors property, JavaConstructorInfo record,
and BuildJavaConstructors scanner method needed by ModelBuilder.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: simonrozsival

src/Microsoft.Android.Sdk.TrimmableTypeMap/Generator/JniSignatureHelper.cs

@@ -1,11 +1,39 @@
 using System;
 using System.Collections.Generic;
+using System.Reflection.Metadata;
+using System.Reflection.Metadata.Ecma335;
 
 namespace Microsoft.Android.Sdk.TrimmableTypeMap;
 
+/// <summary>JNI primitive type kinds used for mapping JNI signatures → CLR types.</summary>
+enum JniParamKind
+{
+	Void,     // V
+	Boolean,  // Z → sbyte
+	Byte,     // B → sbyte
+	Char,     // C → char
+	Short,    // S → short
+	Int,      // I → int
+	Long,     // J → long
+	Float,    // F → float
+	Double,   // D → double
+	Object,   // L...; or [ → IntPtr
+}
+
 /// <summary>Helpers for parsing JNI method signatures.</summary>
 static class JniSignatureHelper
 {
+	/// <summary>Parses the parameter types from a JNI method signature like "(Landroid/os/Bundle;)V".</summary>
+	public static List<JniParamKind> ParseParameterTypes (string jniSignature)
+	{
+		var result = new List<JniParamKind> ();
+		int i = 1; // skip opening '('
+		while (i < jniSignature.Length && jniSignature [i] != ')') {
+			result.Add (ParseSingleType (jniSignature, ref i));
+		}
+		return result;
+	}
+
 	/// <summary>Parses the raw JNI type descriptor strings from a JNI method signature.</summary>
 	public static List<string> ParseParameterTypeStrings (string jniSignature)
 	{
@@ -26,6 +54,37 @@ public static string ParseReturnTypeString (string jniSignature)
 		return jniSignature.Substring (i);
 	}
 
+	/// <summary>Parses the return type from a JNI method signature.</summary>
+	public static JniParamKind ParseReturnType (string jniSignature)
+	{
+		int i = jniSignature.IndexOf (')') + 1;
+		return ParseSingleType (jniSignature, ref i);
+	}
+
+	static JniParamKind ParseSingleType (string sig, ref int i)
+	{
+		switch (sig [i]) {
+		case 'V': i++; return JniParamKind.Void;
+		case 'Z': i++; return JniParamKind.Boolean;
+		case 'B': i++; return JniParamKind.Byte;
+		case 'C': i++; return JniParamKind.Char;
+		case 'S': i++; return JniParamKind.Short;
+		case 'I': i++; return JniParamKind.Int;
+		case 'J': i++; return JniParamKind.Long;
+		case 'F': i++; return JniParamKind.Float;
+		case 'D': i++; return JniParamKind.Double;
+		case 'L':
+			i = sig.IndexOf (';', i) + 1;
+			return JniParamKind.Object;
+		case '[':
+			i++;
+			ParseSingleType (sig, ref i); // skip element type
+			return JniParamKind.Object;
+		default:
+			throw new ArgumentException ($"Unknown JNI type character '{sig [i]}' in '{sig}' at index {i}");
+		}
+	}
+
 	static void SkipSingleType (string sig, ref int i)
 	{
 		switch (sig [i]) {
@@ -44,4 +103,21 @@ static void SkipSingleType (string sig, ref int i)
 			throw new ArgumentException ($"Unknown JNI type character '{sig [i]}' in '{sig}' at index {i}");
 		}
 	}
+
+	/// <summary>Encodes the CLR type for a JNI parameter kind into a signature type encoder.</summary>
+	public static void EncodeClrType (SignatureTypeEncoder encoder, JniParamKind kind)
+	{
+		switch (kind) {
+		case JniParamKind.Boolean: encoder.Boolean (); break;
+		case JniParamKind.Byte:    encoder.SByte (); break;
+		case JniParamKind.Char:    encoder.Char (); break;
+		case JniParamKind.Short:   encoder.Int16 (); break;
+		case JniParamKind.Int:     encoder.Int32 (); break;
+		case JniParamKind.Long:    encoder.Int64 (); break;
+		case JniParamKind.Float:   encoder.Single (); break;
+		case JniParamKind.Double:  encoder.Double (); break;
+		case JniParamKind.Object:  encoder.IntPtr (); break;
+		default: throw new ArgumentException ($"Cannot encode JNI param kind {kind} as CLR type");
+		}
+	}
 }

src/Microsoft.Android.Sdk.TrimmableTypeMap/Scanner/JavaPeerInfo.cs

@@ -67,6 +67,12 @@ sealed record JavaPeerInfo
 	/// </summary>
 	public IReadOnlyList<MarshalMethodInfo> MarshalMethods { get; init; } = Array.Empty<MarshalMethodInfo> ();
 
+	/// <summary>
+	/// Java constructors to emit in the JCW .java file.
+	/// Each has a JNI signature and an ordinal index for the nctor_N native method.
+	/// </summary>
+	public IReadOnlyList<JavaConstructorInfo> JavaConstructors { get; init; } = Array.Empty<JavaConstructorInfo> ();
+
 	/// <summary>
 	/// Information about the activation constructor for this type.
 	/// May reference a base type's constructor if the type doesn't define its own.
@@ -179,6 +185,34 @@ sealed record JniParameterInfo
 	public string ManagedType { get; init; } = "";
 }
 
+/// <summary>
+/// Describes a Java constructor to emit in the JCW .java source file.
+/// </summary>
+sealed record JavaConstructorInfo
+{
+	/// <summary>
+	/// JNI constructor signature, e.g., "(Landroid/content/Context;)V".
+	/// </summary>
+	public required string JniSignature { get; init; }
+
+	/// <summary>
+	/// Ordinal index for the native constructor method (nctor_0, nctor_1, ...).
+	/// </summary>
+	public required int ConstructorIndex { get; init; }
+
+	/// <summary>
+	/// JNI parameter types parsed from the signature.
+	/// Used to generate the Java constructor parameter list.
+	/// </summary>
+	public IReadOnlyList<JniParameterInfo> Parameters { get; init; } = Array.Empty<JniParameterInfo> ();
+
+	/// <summary>
+	/// For [Export] constructors: super constructor arguments string.
+	/// Null for [Register] constructors.
+	/// </summary>
+	public string? SuperArgumentsString { get; init; }
+}
+
 /// <summary>
 /// Describes how to call the activation constructor for a Java peer type.
 /// </summary>

src/Microsoft.Android.Sdk.TrimmableTypeMap/Scanner/JavaPeerScanner.cs

@@ -220,6 +220,7 @@ void ScanAssembly (AssemblyIndex index, Dictionary<string, JavaPeerInfo> results
 				DoNotGenerateAcw = doNotGenerateAcw,
 				IsUnconditional = isUnconditional,
 				MarshalMethods = marshalMethods,
+				JavaConstructors = BuildJavaConstructors (marshalMethods),
 				ActivationCtor = activationCtor,
 				InvokerTypeName = invokerTypeName,
 				IsGenericDefinition = isGenericDefinition,
@@ -708,4 +709,23 @@ static List<JniParameterInfo> ParseJniParameters (string jniSignature)
 		}
 		return result;
 	}
+
+	static List<JavaConstructorInfo> BuildJavaConstructors (List<MarshalMethodInfo> marshalMethods)
+	{
+		var ctors = new List<JavaConstructorInfo> ();
+		int ctorIndex = 0;
+		foreach (var mm in marshalMethods) {
+			if (!mm.IsConstructor) {
+				continue;
+			}
+			ctors.Add (new JavaConstructorInfo {
+				JniSignature = mm.JniSignature,
+				ConstructorIndex = ctorIndex,
+				Parameters = mm.Parameters,
+				SuperArgumentsString = mm.SuperArgumentsString,
+			});
+			ctorIndex++;
+		}
+		return ctors;
+	}
 }

tests/Microsoft.Android.Sdk.TrimmableTypeMap.Tests/Generator/FixtureTestBase.cs

@@ -67,6 +67,9 @@ protected static JavaPeerInfo MakeAcwPeer (string jniName, string managedName, s
 	{
 		var peer = MakePeerWithActivation (jniName, managedName, asmName);
 		peer.DoNotGenerateAcw = false;
+		peer.JavaConstructors = new List<JavaConstructorInfo> {
+			new JavaConstructorInfo { ConstructorIndex = 0, JniSignature = "()V" },
+		};
 		peer.MarshalMethods = new List<MarshalMethodInfo> {
 			new MarshalMethodInfo {
 				JniName = "<init>",

tests/Microsoft.Android.Sdk.TrimmableTypeMap.Tests/Generator/TypeMapAssemblyGeneratorTests.cs

@@ -309,6 +309,62 @@ public void Generate_EmptyPeerList_ProducesValidAssembly ()
 
 	}
 
+	public class JniSignatureHelperTests
+	{
+
+		[Theory]
+		[InlineData ("()V", 0)]
+		[InlineData ("(I)V", 1)]
+		[InlineData ("(Landroid/os/Bundle;)V", 1)]
+		[InlineData ("(IFJ)V", 3)]
+		[InlineData ("(ZLandroid/view/View;I)Z", 3)]
+		[InlineData ("([Ljava/lang/String;)V", 1)]
+		public void ParseParameterTypes_ParsesCorrectCount (string signature, int expectedCount)
+		{
+			var actual = JniSignatureHelper.ParseParameterTypes (signature);
+			Assert.Equal (expectedCount, actual.Count);
+		}
+
+		[Theory]
+		[InlineData ("(Z)V", JniParamKind.Boolean)]
+		[InlineData ("(Ljava/lang/String;)V", JniParamKind.Object)]
+		public void ParseParameterTypes_SingleParam_MapsToCorrectKind (string signature, JniParamKind expectedKind)
+		{
+			var types = JniSignatureHelper.ParseParameterTypes (signature);
+			Assert.Single (types);
+			Assert.Equal (expectedKind, types [0]);
+		}
+
+		[Theory]
+		[InlineData ("()V", JniParamKind.Void)]
+		[InlineData ("()I", JniParamKind.Int)]
+		[InlineData ("()Z", JniParamKind.Boolean)]
+		[InlineData ("()Ljava/lang/String;", JniParamKind.Object)]
+		public void ParseReturnType_MapsToCorrectKind (string signature, JniParamKind expectedKind)
+		{
+			Assert.Equal (expectedKind, JniSignatureHelper.ParseReturnType (signature));
+		}
+
+	}
+
+	public class NegativeEdgeCase
+	{
+
+		[Theory]
+		[InlineData ("")]
+		[InlineData ("not-a-sig")]
+		[InlineData ("(")]
+		public void ParseParameterTypes_InvalidSignature_ThrowsOrReturnsEmpty (string signature)
+		{
+			try {
+				var result = JniSignatureHelper.ParseParameterTypes (signature);
+				Assert.NotNull (result);
+			} catch (Exception ex) when (ex is ArgumentException || ex is IndexOutOfRangeException || ex is FormatException) {
+			}
+		}
+
+	}
+
 	public class CreateInstancePaths
 	{