From 984f5dd8829a16696380535c9aa627683d41ef35 Mon Sep 17 00:00:00 2001 From: Simon Rozsival Date: Mon, 31 Aug 2026 10:58:49 +0200 Subject: [PATCH 01/14] [typemap] Diagnose unsupported export signatures Reject unresolved managed, generic, and function-pointer export signatures during trimmable scanning with localized XA4263 diagnostics before any typemap, Java, or ACW-map output is written. Preserve legacy XA4206 precedence and supported Java mappings. Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com> --- Documentation/docs-mobile/TOC.yml | 2 + Documentation/docs-mobile/messages/index.md | 1 + Documentation/docs-mobile/messages/xa4263.md | 24 +++ .../ITrimmableTypeMapLogger.cs | 2 + .../Scanner/JavaPeerScanner.cs | 114 ++++++++++- .../Properties/Resources.Designer.cs | 10 + .../Properties/Resources.resx | 6 + .../Tasks/GenerateTrimmableTypeMap.cs | 4 + .../TrimmableTypeMapBuildTests.cs | 180 ++++++++++++++++++ .../Generator/ExportSignatureTests.cs | 26 +++ .../TrimmableTypeMapGeneratorTests.cs | 29 +++ .../TestFixtures/TestTypes.cs | 46 +++++ 12 files changed, 437 insertions(+), 7 deletions(-) create mode 100644 Documentation/docs-mobile/messages/xa4263.md create mode 100644 tests/Microsoft.Android.Sdk.TrimmableTypeMap.Tests/Generator/ExportSignatureTests.cs diff --git a/Documentation/docs-mobile/TOC.yml b/Documentation/docs-mobile/TOC.yml index 1244c066b05..03bfd8e5f0e 100644 --- a/Documentation/docs-mobile/TOC.yml +++ b/Documentation/docs-mobile/TOC.yml @@ -332,6 +332,8 @@ href: messages/xa4249.md - name: XA4258 href: messages/xa4258.md + - name: XA4263 + href: messages/xa4263.md - name: XA4301 href: messages/xa4301.md - name: XA4302 diff --git a/Documentation/docs-mobile/messages/index.md b/Documentation/docs-mobile/messages/index.md index dabb47571de..4c17d558c1c 100644 --- a/Documentation/docs-mobile/messages/index.md +++ b/Documentation/docs-mobile/messages/index.md @@ -229,6 +229,7 @@ Either change the value in the AndroidManifest.xml to match the $(SupportedOSPla + [XA4255](xa4255.md): Generated trimmable type map Java source '{path}' was not found. + [XA4256](xa4256.md): Skipping Java peer type '{type}' from assembly '{assembly}' because referenced type '{referencedType}' from assembly '{referencedAssembly}' could not be resolved in '{path}'. This type will not be included in the trimmable type map. + [XA4258](xa4258.md): Java name '{name}' contains reserved Java identifier '{identifier}'. Change the package or type name. ++ [XA4263](xa4263.md): The exported member '{member}' has unsupported signature type '{type}'. Use a Java peer type, a supported managed-to-Java mapping, or [ExportParameter]. + XA4300: Native library '{library}' will not be bundled because it has an unsupported ABI. + [XA4301](xa4301.md): Apk already contains the item `xxx`. + [XA4302](xa4302.md): Unhandled exception merging \`AndroidManifest.xml\`: {ex} diff --git a/Documentation/docs-mobile/messages/xa4263.md b/Documentation/docs-mobile/messages/xa4263.md new file mode 100644 index 00000000000..392a7a7d8de --- /dev/null +++ b/Documentation/docs-mobile/messages/xa4263.md @@ -0,0 +1,24 @@ +--- +title: .NET for Android error XA4263 +description: XA4263 error code +ms.date: 08/31/2026 +f1_keywords: + - "XA4263" +--- + +# .NET for Android error XA4263 + +## Example message + +```text +error XA4263: The exported member 'Peer.Get' has unsupported signature type 'ManagedValue'. Use a Java peer type, a supported managed-to-Java mapping, or [ExportParameter]. +``` + +## Issue + +An `[Export]` method or `[ExportField]` initializer uses a managed parameter or return type that has no Java type mapping. +The type cannot be represented safely in the generated Java declaration. + +## Solution + +Use a primitive, string, array, Java peer, or another supported managed-to-Java type. For `Stream` or `XmlReader`, apply `[ExportParameter]` with the appropriate Java mapping. diff --git a/src/Microsoft.Android.Sdk.TrimmableTypeMap/ITrimmableTypeMapLogger.cs b/src/Microsoft.Android.Sdk.TrimmableTypeMap/ITrimmableTypeMapLogger.cs index 879bf42aafc..edd36592f83 100644 --- a/src/Microsoft.Android.Sdk.TrimmableTypeMap/ITrimmableTypeMapLogger.cs +++ b/src/Microsoft.Android.Sdk.TrimmableTypeMap/ITrimmableTypeMapLogger.cs @@ -23,8 +23,10 @@ void LogUnresolvableJavaPeerSkippedWarning ( void LogJniAddNativeMethodRegistrationAttributeError (string managedTypeName); void LogInvalidJavaNameError (string javaName, string invalidIdentifier); void LogExportFieldWithParametersError (); + void LogExportOnGenericTypeError (); void LogExportFieldOnGenericTypeError (); void LogExportFieldReturnsVoidError (); + void LogUnsupportedExportSignatureError (string memberName, string managedTypeName); void LogCustomJavaObjectError (string managedTypeName); void LogCustomJavaObjectWarning (string managedTypeName); } diff --git a/src/Microsoft.Android.Sdk.TrimmableTypeMap/Scanner/JavaPeerScanner.cs b/src/Microsoft.Android.Sdk.TrimmableTypeMap/Scanner/JavaPeerScanner.cs index 6cf34b2693e..291a2d79a7e 100644 --- a/src/Microsoft.Android.Sdk.TrimmableTypeMap/Scanner/JavaPeerScanner.cs +++ b/src/Microsoft.Android.Sdk.TrimmableTypeMap/Scanner/JavaPeerScanner.cs @@ -681,6 +681,9 @@ static void SkipArrayShape (ref BlobReader reader) if (!ValidateExportField (methodDef, index, isGenericType)) { continue; } + if (!ValidateExportSignature (methodDef, index, isGenericType)) { + continue; + } // Check for [ExportField] — produces both a marshal method AND a field CollectExportField (methodDef, index, fields); @@ -778,6 +781,79 @@ bool ValidateExportField (MethodDefinition methodDef, AssemblyIndex index, bool return true; } + bool ValidateExportSignature (MethodDefinition methodDef, AssemblyIndex index, bool isGenericType) + { + bool isExport = false; + bool isExportField = false; + foreach (var caHandle in methodDef.GetCustomAttributes ()) { + var ca = index.Reader.GetCustomAttribute (caHandle); + var attrName = AssemblyIndex.GetCustomAttributeName (ca, index.Reader); + if (attrName == "ExportAttribute") { + isExport = true; + } else if (IsExportFieldAttribute (ca, index)) { + isExportField = true; + } + } + if (!isExport && !isExportField) { + return true; + } + + var methodName = index.Reader.GetString (methodDef.Name); + if (methodName is ".ctor" or ".cctor") { + return true; + } + if (isExport && isGenericType) { + logger?.LogExportOnGenericTypeError (); + return false; + } + + var sig = methodDef.DecodeSignature (TypeRefSignatureTypeProvider.Instance, index); + var (parameterKinds, returnKind) = isExport + ? GetExportParameterKinds (methodDef, index, sig.ParameterTypes.Length) + : (CreateDefaultExportKinds (sig.ParameterTypes.Length), ExportParameterKindInfo.Unspecified); + var declaringType = index.Reader.GetTypeDefinition (methodDef.GetDeclaringType ()); + string declaringTypeName = MetadataTypeNameResolver.GetFullName (declaringType, index.Reader); + string memberName = $"{declaringTypeName}.{methodName}"; + + for (int i = 0; i < sig.ParameterTypes.Length; i++) { + if (!HasExportSignatureMapping (sig.ParameterTypes [i], parameterKinds [i])) { + logger?.LogUnsupportedExportSignatureError (memberName, sig.ParameterTypes [i].DisplayName); + return false; + } + } + if (!HasExportSignatureMapping (sig.ReturnType, returnKind)) { + logger?.LogUnsupportedExportSignatureError (memberName, sig.ReturnType.DisplayName); + return false; + } + return true; + } + + bool HasExportSignatureMapping (TypeRefData managedType, ExportParameterKindInfo exportKind) + { + if (TryManagedTypeToJniDescriptor (managedType, exportKind, out _)) { + return true; + } + + // Legacy maps by-ref, pointer, and rectangular-array signatures through their + // element type. Their trimmable dispatch parity is tracked separately; do not + // turn llvm-ir-supported signatures into trimmable-only diagnostics here. + string managedTypeName = managedType.ManagedTypeName; + if (managedTypeName.EndsWith ("&", StringComparison.Ordinal) || + managedTypeName.EndsWith ("*", StringComparison.Ordinal)) { + return TryManagedTypeToJniDescriptor (managedType with { + ManagedTypeName = managedTypeName.Substring (0, managedTypeName.Length - 1), + }, exportKind, out _); + } + + int arrayStart = managedTypeName.LastIndexOf ('['); + if (arrayStart >= 0 && managedTypeName.EndsWith ("]", StringComparison.Ordinal)) { + return TryManagedTypeToJniDescriptor (managedType with { + ManagedTypeName = managedTypeName.Substring (0, arrayStart), + }, exportKind, out _); + } + return false; + } + static bool HasJniAddNativeMethodRegistrationAttribute (TypeDefinition typeDef, AssemblyIndex index) { const string JniAddNativeMethodRegistrationAttribute = "JniAddNativeMethodRegistrationAttribute"; @@ -1956,30 +2032,51 @@ string BuildJniSignatureFromManaged (MethodSignature sig, IReadOnly /// for types that cannot be resolved (used by [Export] signature computation). /// string ManagedTypeToJniDescriptor (TypeRefData managedType, ExportParameterKindInfo exportKind = ExportParameterKindInfo.Unspecified) + { + return TryManagedTypeToJniDescriptor (managedType, exportKind, out var descriptor) + ? descriptor + : "Ljava/lang/Object;"; + } + + bool TryManagedTypeToJniDescriptor ( + TypeRefData managedType, + ExportParameterKindInfo exportKind, + out string descriptor) { if (exportKind != ExportParameterKindInfo.Unspecified) { - return exportKind switch { + descriptor = exportKind switch { ExportParameterKindInfo.InputStream => "Ljava/io/InputStream;", ExportParameterKindInfo.OutputStream => "Ljava/io/OutputStream;", ExportParameterKindInfo.XmlPullParser => "Lorg/xmlpull/v1/XmlPullParser;", ExportParameterKindInfo.XmlResourceParser => "Landroid/content/res/XmlResourceParser;", _ => "Ljava/lang/Object;", }; + return true; } var primitive = TryGetPrimitiveJniDescriptor (managedType.ManagedTypeName); if (primitive is not null) { - return primitive; + descriptor = primitive; + return true; } if (managedType.ManagedTypeName.EndsWith ("[]", StringComparison.Ordinal)) { - return $"[{ManagedTypeToJniDescriptor (managedType with { ManagedTypeName = managedType.ManagedTypeName.Substring (0, managedType.ManagedTypeName.Length - 2) })}"; + var elementType = managedType with { + ManagedTypeName = managedType.ManagedTypeName.Substring (0, managedType.ManagedTypeName.Length - 2), + }; + if (TryManagedTypeToJniDescriptor (elementType, exportKind, out var elementDescriptor)) { + descriptor = $"[{elementDescriptor}"; + return true; + } + descriptor = ""; + return false; } // Try to resolve as a Java peer type with [Register] var resolved = TryResolveJniObjectDescriptor (managedType.ManagedTypeName); if (resolved is not null) { - return resolved; + descriptor = resolved; + return true; } // Well-known interface types that legacy CallbackCode mapped explicitly @@ -1995,17 +2092,20 @@ string ManagedTypeToJniDescriptor (TypeRefData managedType, ExportParameterKindI _ => null, }; if (wellKnown is not null) { - return wellKnown; + descriptor = wellKnown; + return true; } // Enum parameters use their underlying primitive JNI ABI (matches legacy // CallbackCode behavior). var enumDescriptor = TryResolveEnumUnderlyingDescriptor (managedType.ManagedTypeName, managedType.AssemblyName); if (enumDescriptor is not null) { - return enumDescriptor; + descriptor = enumDescriptor; + return true; } - return "Ljava/lang/Object;"; + descriptor = ""; + return false; } /// diff --git a/src/Xamarin.Android.Build.Tasks/Properties/Resources.Designer.cs b/src/Xamarin.Android.Build.Tasks/Properties/Resources.Designer.cs index db2a9c4243c..58dced9b792 100644 --- a/src/Xamarin.Android.Build.Tasks/Properties/Resources.Designer.cs +++ b/src/Xamarin.Android.Build.Tasks/Properties/Resources.Designer.cs @@ -1668,6 +1668,16 @@ public static string XA4258 { } } + /// + /// Looks up a localized string similar to The exported member '{0}' has unsupported signature type '{1}'. + /// Use a Java peer type, a supported managed-to-Java mapping, or [ExportParameter].. + /// + public static string XA4263 { + get { + return ResourceManager.GetString("XA4263", resourceCulture); + } + } + /// /// Looks up a localized string similar to Native library '{0}' will not be bundled because it has an unsupported ABI. Move this file to a directory with a valid Android ABI name such as 'libs/armeabi-v7a/'.. /// diff --git a/src/Xamarin.Android.Build.Tasks/Properties/Resources.resx b/src/Xamarin.Android.Build.Tasks/Properties/Resources.resx index aef2dbc527a..37d338c5f2b 100644 --- a/src/Xamarin.Android.Build.Tasks/Properties/Resources.resx +++ b/src/Xamarin.Android.Build.Tasks/Properties/Resources.resx @@ -1242,6 +1242,12 @@ To use a custom JDK path for a command line build, set the 'JavaSdkDirectory' MS The following are literal names and should not be translated: Java. {0} - Java package or type name {1} - Java reserved keyword or restricted identifier + + + The exported member '{0}' has unsupported signature type '{1}'. Use a Java peer type, a supported managed-to-Java mapping, or [ExportParameter]. + The following are literal names and should not be translated: Java, [ExportParameter]. +{0} - Fully-qualified managed member name +{1} - Managed parameter or return type Command '{0}' failed.\n{1} diff --git a/src/Xamarin.Android.Build.Tasks/Tasks/GenerateTrimmableTypeMap.cs b/src/Xamarin.Android.Build.Tasks/Tasks/GenerateTrimmableTypeMap.cs index 1c2b02aa583..f9121daccb3 100644 --- a/src/Xamarin.Android.Build.Tasks/Tasks/GenerateTrimmableTypeMap.cs +++ b/src/Xamarin.Android.Build.Tasks/Tasks/GenerateTrimmableTypeMap.cs @@ -61,10 +61,14 @@ public void LogInvalidJavaNameError (string javaName, string invalidIdentifier) log.LogCodedError ("XA4258", Properties.Resources.XA4258, javaName, invalidIdentifier); public void LogExportFieldWithParametersError () => log.LogCodedError ("XA4205", Java.Interop.Localization.Resources.JavaCallableWrappers_XA4205); + public void LogExportOnGenericTypeError () => + log.LogCodedError ("XA4206", Java.Interop.Localization.Resources.JavaCallableWrappers_XA4206); public void LogExportFieldOnGenericTypeError () => log.LogCodedError ("XA4207", Java.Interop.Localization.Resources.JavaCallableWrappers_XA4207); public void LogExportFieldReturnsVoidError () => log.LogCodedError ("XA4208", Java.Interop.Localization.Resources.JavaCallableWrappers_XA4208); + public void LogUnsupportedExportSignatureError (string memberName, string managedTypeName) => + log.LogCodedError ("XA4263", Properties.Resources.XA4263, memberName, managedTypeName); public void LogCustomJavaObjectError (string managedTypeName) => log.LogError ("{0}", $"XA4212: {string.Format (Properties.Resources.XA4212, managedTypeName)}"); public void LogCustomJavaObjectWarning (string managedTypeName) => diff --git a/src/Xamarin.Android.Build.Tasks/Tests/Xamarin.Android.Build.Tests/TrimmableTypeMapBuildTests.cs b/src/Xamarin.Android.Build.Tasks/Tests/Xamarin.Android.Build.Tests/TrimmableTypeMapBuildTests.cs index a426a5b7f0d..7ebeb6be607 100644 --- a/src/Xamarin.Android.Build.Tasks/Tests/Xamarin.Android.Build.Tests/TrimmableTypeMapBuildTests.cs +++ b/src/Xamarin.Android.Build.Tasks/Tests/Xamarin.Android.Build.Tests/TrimmableTypeMapBuildTests.cs @@ -95,6 +95,119 @@ public void Build_InvalidExportField_ReportsLegacyDiagnostic ( } } + [TestCase ("llvm-ir", AndroidRuntime.CoreCLR, "arbitrary-parameter", "XALNS7003")] + [TestCase ("trimmable", AndroidRuntime.CoreCLR, "arbitrary-parameter", "XA4263")] + [TestCase ("trimmable", AndroidRuntime.NativeAOT, "arbitrary-parameter", "XA4263")] + [TestCase ("llvm-ir", AndroidRuntime.CoreCLR, "arbitrary-return", "XALNS7003")] + [TestCase ("trimmable", AndroidRuntime.CoreCLR, "arbitrary-return", "XA4263")] + [TestCase ("trimmable", AndroidRuntime.NativeAOT, "arbitrary-return", "XA4263")] + [TestCase ("llvm-ir", AndroidRuntime.CoreCLR, "arbitrary-field", "XALNS7003")] + [TestCase ("trimmable", AndroidRuntime.CoreCLR, "arbitrary-field", "XA4263")] + [TestCase ("trimmable", AndroidRuntime.NativeAOT, "arbitrary-field", "XA4263")] + [TestCase ("llvm-ir", AndroidRuntime.CoreCLR, "generic-parameter", "XALNS7003")] + [TestCase ("trimmable", AndroidRuntime.CoreCLR, "generic-parameter", "XA4263")] + [TestCase ("trimmable", AndroidRuntime.NativeAOT, "generic-parameter", "XA4263")] + [TestCase ("llvm-ir", AndroidRuntime.CoreCLR, "generic-instantiation", "XALNS7003")] + [TestCase ("trimmable", AndroidRuntime.CoreCLR, "generic-instantiation", "XA4263")] + [TestCase ("trimmable", AndroidRuntime.NativeAOT, "generic-instantiation", "XA4263")] + [TestCase ("llvm-ir", AndroidRuntime.CoreCLR, "function-pointer", "XALNS7003")] + [TestCase ("trimmable", AndroidRuntime.CoreCLR, "function-pointer", "XA4263")] + [TestCase ("trimmable", AndroidRuntime.NativeAOT, "function-pointer", "XA4263")] + [TestCase ("llvm-ir", AndroidRuntime.CoreCLR, "generic-declaring-type", "XA4206")] + [TestCase ("trimmable", AndroidRuntime.CoreCLR, "generic-declaring-type", "XA4206")] + [TestCase ("trimmable", AndroidRuntime.NativeAOT, "generic-declaring-type", "XA4206")] + public void Build_UnsupportedExportSignature_ReportsCodedDiagnosticWithoutPartialOutputs ( + string typeMapImplementation, + AndroidRuntime runtime, + string invalidShape, + string expectedCode) + { + bool isRelease = runtime == AndroidRuntime.NativeAOT; + if (IgnoreUnsupportedConfiguration (runtime, release: isRelease)) { + return; + } + + var (additionalTypes, member, marker, typeParameters) = invalidShape switch { + "arbitrary-parameter" => ( + "public sealed class ManagedOnly { }", + """[Export ("unsupported")] public void UnsupportedMember (ManagedOnly value) { }""", + "unsupported", + ""), + "arbitrary-return" => ( + "public sealed class ManagedOnly { }", + """[Export ("unsupported")] public ManagedOnly UnsupportedMember () => new ();""", + "unsupported", + ""), + "arbitrary-field" => ( + "public sealed class ManagedOnly { }", + """[ExportField ("UNSUPPORTED_FIELD")] public ManagedOnly UnsupportedMember () => new ();""", + "UNSUPPORTED_FIELD", + ""), + "generic-parameter" => ( + "", + """[Export ("unsupported")] public T UnsupportedMember (T value) => value;""", + "unsupported", + ""), + "generic-instantiation" => ( + "", + """[Export ("unsupported")] public List UnsupportedMember (List value) => value;""", + "unsupported", + ""), + "function-pointer" => ( + "", + """[Export ("unsupported")] public unsafe delegate* unmanaged UnsupportedMember (delegate* unmanaged value) => value;""", + "unsupported", + ""), + "generic-declaring-type" => ( + "", + """[Export ("unsupported")] public int UnsupportedMember () => 0;""", + "unsupported", + ""), + _ => throw new InvalidOperationException ($"Unknown unsupported [Export] shape '{invalidShape}'."), + }; + var proj = new XamarinAndroidApplicationProject { + IsRelease = isRelease, + References = { + new BuildItem.Reference ("Mono.Android.Export"), + }, + }; + proj.SetRuntime (runtime); + proj.SetProperty ("AndroidTypeMapImplementation", typeMapImplementation); + proj.SetProperty ("AllowUnsafeBlocks", "true"); + proj.Sources.Add (new BuildItem.Source ("ExportSignatureValidation.cs") { + TextContent = () => $$""" + using System.Collections.Generic; + using Android.Runtime; + using Java.Interop; + + namespace ExportSignatureValidation { + {{additionalTypes}} + + [Register ("com/example/exports/SignaturePeer")] + public class SignaturePeer{{typeParameters}} : Java.Lang.Object { + public SignaturePeer () { + } + + {{member}} + } + } + """, + }); + + using var builder = CreateApkBuilder (); + builder.ThrowOnBuildFailure = false; + Assert.IsFalse (builder.Build (proj), $"{runtime}/{typeMapImplementation} should reject {invalidShape}."); + StringAssertEx.Contains ($"error {expectedCode}", builder.LastBuildOutput, $"The build should report {expectedCode}."); + if (expectedCode == "XA4263") { + StringAssertEx.Contains ( + "ExportSignatureValidation.SignaturePeer.UnsupportedMember", + builder.LastBuildOutput, + "The diagnostic should identify the unsupported managed member." + ); + } + AssertNoExportOutputs (builder, marker); + } + static XamarinAndroidApplicationProject CreateExportFieldValidationProject ( AndroidRuntime runtime, string typeMapImplementation, @@ -129,6 +242,73 @@ public ValidationPeer () { return proj; } + [Test] + public void FindExportOutputs_FindsEveryArtifactKind () + { + var root = Path.Combine (Root, "temp", TestName); + var typemapDirectory = Path.Combine (root, "typemap"); + var acwMapFile = Path.Combine (root, "acw-map.txt"); + var trimmableJavaDirectory = Path.Combine (typemapDirectory, "java", "com", "example"); + var llvmIrJavaDirectory = Path.Combine (root, "android", "src", "com", "example"); + Directory.CreateDirectory (trimmableJavaDirectory); + Directory.CreateDirectory (llvmIrJavaDirectory); + + var expected = new [] { + Path.Combine (typemapDirectory, "_Example.TypeMap.dll"), + Path.Combine (typemapDirectory, "_Microsoft.Android.TypeMaps.dll"), + acwMapFile, + Path.Combine (trimmableJavaDirectory, "TrimmablePeer.java"), + Path.Combine (llvmIrJavaDirectory, "LlvmIrPeer.java"), + }; + File.WriteAllBytes (expected [0], []); + File.WriteAllBytes (expected [1], []); + File.WriteAllText (expected [2], "Managed, Assembly;com/example/Peer"); + File.WriteAllText (expected [3], "public int VALUE = InitialValue ();"); + File.WriteAllText (expected [4], "public int VALUE = InitialValue ();"); + + CollectionAssert.AreEquivalent ( + expected, + FindExportOutputs (typemapDirectory, acwMapFile, Path.Combine (root, "android", "src"), "VALUE") + ); + } + + static void AssertNoExportOutputs (ProjectBuilder builder, string memberName) + { + var typemapDirectory = builder.Output.GetIntermediaryPath ("typemap"); + var acwMapFile = builder.Output.GetIntermediaryPath ("acw-map.txt"); + var androidSourceDirectory = builder.Output.GetIntermediaryPath (Path.Combine ("android", "src")); + var outputs = FindExportOutputs (typemapDirectory, acwMapFile, androidSourceDirectory, memberName); + Assert.IsEmpty ( + outputs, + "Invalid exported metadata should not produce typemap assemblies, ACW maps, or partial Java output:" + + Environment.NewLine + string.Join (Environment.NewLine, outputs) + ); + } + + static string [] FindExportOutputs (string typemapDirectory, string acwMapFile, string androidSourceDirectory, string memberName) + { + var outputs = new List (); + if (Directory.Exists (typemapDirectory)) { + outputs.AddRange (Directory.GetFiles (typemapDirectory, "*.TypeMap.dll", SearchOption.AllDirectories)); + outputs.AddRange (Directory.GetFiles (typemapDirectory, "_Microsoft.Android.TypeMaps.dll", SearchOption.AllDirectories)); + } + if (File.Exists (acwMapFile)) { + outputs.Add (acwMapFile); + } + + foreach (var javaDirectory in new [] { Path.Combine (typemapDirectory, "java"), androidSourceDirectory }) { + if (!Directory.Exists (javaDirectory)) { + continue; + } + foreach (var javaFile in Directory.GetFiles (javaDirectory, "*.java", SearchOption.AllDirectories)) { + if (File.ReadAllText (javaFile).Contains (memberName, StringComparison.Ordinal)) { + outputs.Add (javaFile); + } + } + } + return outputs.ToArray (); + } + [Test] public void Build_PublishAotProject_UsesTrimmableTypeMapForCoreClrDebug () { diff --git a/tests/Microsoft.Android.Sdk.TrimmableTypeMap.Tests/Generator/ExportSignatureTests.cs b/tests/Microsoft.Android.Sdk.TrimmableTypeMap.Tests/Generator/ExportSignatureTests.cs new file mode 100644 index 00000000000..b092903f13f --- /dev/null +++ b/tests/Microsoft.Android.Sdk.TrimmableTypeMap.Tests/Generator/ExportSignatureTests.cs @@ -0,0 +1,26 @@ +using System.IO; +using Xunit; + +namespace Microsoft.Android.Sdk.TrimmableTypeMap.Tests; + +public class ExportSignatureTests : FixtureTestBase +{ + [Theory] + [InlineData ("my/app/ExportWithUnsupportedManagedParameter")] + [InlineData ("my/app/ExportWithUnsupportedManagedReturn")] + [InlineData ("my/app/ExportFieldWithUnsupportedManagedReturn")] + [InlineData ("my/app/ExportWithGenericMethodParameter")] + [InlineData ("my/app/ExportWithGenericInstantiation")] + [InlineData ("my/app/GenericExportType")] + public void ScannerAndGenerator_UnsupportedExportSignatureProducesNoMember (string javaName) + { + var peer = FindFixtureByJavaName (javaName); + + Assert.DoesNotContain (peer.MarshalMethods, method => method.ManagedMethodName == "UnsupportedMember"); + Assert.Empty (peer.JavaFields); + + using var writer = new StringWriter (); + new JcwJavaSourceGenerator ().Generate (peer, writer); + Assert.DoesNotContain (" unsupported (", writer.ToString (), System.StringComparison.Ordinal); + } +} diff --git a/tests/Microsoft.Android.Sdk.TrimmableTypeMap.Tests/Generator/TrimmableTypeMapGeneratorTests.cs b/tests/Microsoft.Android.Sdk.TrimmableTypeMap.Tests/Generator/TrimmableTypeMapGeneratorTests.cs index 64cd0919df9..b939dc8407d 100644 --- a/tests/Microsoft.Android.Sdk.TrimmableTypeMap.Tests/Generator/TrimmableTypeMapGeneratorTests.cs +++ b/tests/Microsoft.Android.Sdk.TrimmableTypeMap.Tests/Generator/TrimmableTypeMapGeneratorTests.cs @@ -55,10 +55,14 @@ public void LogInvalidJavaNameError (string javaName, string invalidIdentifier) logMessages.Add ($"XA4258: Java name '{javaName}' contains reserved Java identifier '{invalidIdentifier}'."); public void LogExportFieldWithParametersError () => logMessages.Add ("XA4205: [ExportField] can only be used on methods with 0 parameters."); + public void LogExportOnGenericTypeError () => + logMessages.Add ("XA4206: [Export] cannot be used on a generic type."); public void LogExportFieldReturnsVoidError () => logMessages.Add ("XA4208: [ExportField] cannot be used on a method returning 'void'."); public void LogExportFieldOnGenericTypeError () => logMessages.Add ("XA4207: [ExportField] cannot be used on a generic type."); + public void LogUnsupportedExportSignatureError (string memberName, string managedTypeName) => + logMessages.Add ($"XA4263: The exported member '{memberName}' has unsupported signature type '{managedTypeName}'."); public void LogCustomJavaObjectError (string managedTypeName) => logMessages.Add ($"XA4212: Type `{managedTypeName}` implements `Android.Runtime.IJavaObject` but does not inherit `Java.Lang.Object` or `Java.Lang.Throwable`. This is not supported."); public void LogCustomJavaObjectWarning (string managedTypeName) => @@ -346,6 +350,31 @@ public void Execute_CanSkipUnusedNonAcwMarshalMethods () } } + [Fact] + public void Execute_UnsupportedExportSignatures_ReportCodedDiagnosticsWithoutPartialMembers () + { + using var peReader = CreateTestFixturePEReader (); + var result = CreateGenerator ().Execute ([Input ("TestFixtures", peReader)], new Version (11, 0), new HashSet ()); + + Assert.Equal (5, logMessages.Count (message => message.StartsWith ("XA4263:", StringComparison.Ordinal))); + Assert.Equal (1, logMessages.Count (message => message.StartsWith ("XA4206:", StringComparison.Ordinal))); + foreach (var javaName in new [] { + "my/app/ExportWithUnsupportedManagedParameter", + "my/app/ExportWithUnsupportedManagedReturn", + "my/app/ExportFieldWithUnsupportedManagedReturn", + "my/app/ExportWithGenericMethodParameter", + "my/app/ExportWithGenericInstantiation", + "my/app/GenericExportType", + }) { + var peer = result.AllPeers.Single (candidate => candidate.JavaName == javaName); + Assert.DoesNotContain (peer.MarshalMethods, method => method.ManagedMethodName == "UnsupportedMember"); + Assert.Empty (peer.JavaFields); + var source = result.GeneratedJavaSources.Single (candidate => candidate.RelativePath == javaName + ".java"); + Assert.DoesNotContain (" unsupported (", source.Content, StringComparison.Ordinal); + Assert.DoesNotContain ("UNSUPPORTED_FIELD", source.Content, StringComparison.Ordinal); + } + } + [Fact] public void Execute_CollectsDeferredRegistrationTypes_ForAllApplicationAndInstrumentationSubtypes () { diff --git a/tests/Microsoft.Android.Sdk.TrimmableTypeMap.Tests/TestFixtures/TestTypes.cs b/tests/Microsoft.Android.Sdk.TrimmableTypeMap.Tests/TestFixtures/TestTypes.cs index 5d0b6000196..2e70958ba64 100644 --- a/tests/Microsoft.Android.Sdk.TrimmableTypeMap.Tests/TestFixtures/TestTypes.cs +++ b/tests/Microsoft.Android.Sdk.TrimmableTypeMap.Tests/TestFixtures/TestTypes.cs @@ -580,6 +580,52 @@ public class ExportCollectionShapes : Java.Lang.Object public System.Collections.ICollection? EchoCollection (System.Collections.ICollection? value) => value; } + public class UnsupportedExportValue + { + } + + [Register ("my/app/ExportWithUnsupportedManagedParameter")] + public class ExportWithUnsupportedManagedParameter : Java.Lang.Object + { + [Java.Interop.Export ("unsupported")] + public void UnsupportedMember (UnsupportedExportValue value) { } + } + + [Register ("my/app/ExportWithUnsupportedManagedReturn")] + public class ExportWithUnsupportedManagedReturn : Java.Lang.Object + { + [Java.Interop.Export ("unsupported")] + public UnsupportedExportValue UnsupportedMember () => new (); + } + + [Register ("my/app/ExportFieldWithUnsupportedManagedReturn")] + public class ExportFieldWithUnsupportedManagedReturn : Java.Lang.Object + { + [Java.Interop.ExportField ("UNSUPPORTED_FIELD")] + public UnsupportedExportValue UnsupportedMember () => new (); + } + + [Register ("my/app/ExportWithGenericMethodParameter")] + public class ExportWithGenericMethodParameter : Java.Lang.Object + { + [Java.Interop.Export ("unsupported")] + public T UnsupportedMember (T value) => value; + } + + [Register ("my/app/ExportWithGenericInstantiation")] + public class ExportWithGenericInstantiation : Java.Lang.Object + { + [Java.Interop.Export ("unsupported")] + public System.Collections.Generic.List UnsupportedMember (System.Collections.Generic.List value) => value; + } + + [Register ("my/app/GenericExportType")] + public class GenericExportType : Java.Lang.Object + { + [Java.Interop.Export ("unsupported")] + public int UnsupportedMember () => 0; + } + /// /// Has [Export] methods with different access modifiers. /// The JCW should respect the C# visibility for [Export] methods. From 63c6c8f219a58b191123ffb40f8e3a47516e0609 Mon Sep 17 00:00:00 2001 From: Simon Rozsival Date: Mon, 31 Aug 2026 11:45:50 +0200 Subject: [PATCH 02/14] [typemap] Correct export signature validation Honor ExportParameter return mappings on exported fields, reject incompatible special mappings before generation, and resolve Java peer descriptors by assembly identity through type forwarders. Add semantic, cross-assembly, and three-runtime regressions. Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com> --- Documentation/docs-mobile/messages/xa4263.md | 4 +- .../Scanner/AssemblyIndex.cs | 26 +++- .../Scanner/JavaPeerScanner.cs | 134 ++++++++++++------ .../TrimmableTypeMapBuildTests.cs | 51 +++++++ .../ScannerExportShapesTests.cs | 25 +++- .../UserTypesFixture/UserTypes.cs | 25 ++++ .../Generator/ExportFieldTests.cs | 12 ++ .../Generator/ExportSignatureTests.cs | 3 + .../TrimmableTypeMapGeneratorTests.cs | 5 +- .../TestFixtures/TestTypes.cs | 34 +++++ 10 files changed, 271 insertions(+), 48 deletions(-) diff --git a/Documentation/docs-mobile/messages/xa4263.md b/Documentation/docs-mobile/messages/xa4263.md index 392a7a7d8de..3da646d645d 100644 --- a/Documentation/docs-mobile/messages/xa4263.md +++ b/Documentation/docs-mobile/messages/xa4263.md @@ -18,7 +18,9 @@ error XA4263: The exported member 'Peer.Get' has unsupported signature type 'Man An `[Export]` method or `[ExportField]` initializer uses a managed parameter or return type that has no Java type mapping. The type cannot be represented safely in the generated Java declaration. +This error also occurs when `[ExportParameter]` specifies a Java mapping that is incompatible with the managed type. ## Solution -Use a primitive, string, array, Java peer, or another supported managed-to-Java type. For `Stream` or `XmlReader`, apply `[ExportParameter]` with the appropriate Java mapping. +Use a primitive, string, array, Java peer, or another supported managed-to-Java type. +Apply input/output stream mappings only to `Stream`, and XML parser mappings only to `XmlReader`. diff --git a/src/Microsoft.Android.Sdk.TrimmableTypeMap/Scanner/AssemblyIndex.cs b/src/Microsoft.Android.Sdk.TrimmableTypeMap/Scanner/AssemblyIndex.cs index 30ca13c1b06..b0182877d6a 100644 --- a/src/Microsoft.Android.Sdk.TrimmableTypeMap/Scanner/AssemblyIndex.cs +++ b/src/Microsoft.Android.Sdk.TrimmableTypeMap/Scanner/AssemblyIndex.cs @@ -30,6 +30,7 @@ sealed class AssemblyIndex : IDisposable public MetadataReader Reader { get; } public string AssemblyName { get; } + public string MetadataAssemblyName { get; } public string AssemblyPath { get; } internal TypeRefSignatureTypeProvider TypeRefSignatureProvider { get; } @@ -53,6 +54,11 @@ sealed class AssemblyIndex : IDisposable /// public HashSet ExportedTypeNames { get; } = new (StringComparer.Ordinal); + /// + /// Maps forwarded managed type names to the target assembly simple name. + /// + public Dictionary ForwardedTypeAssemblies { get; } = new (StringComparer.Ordinal); + /// /// True iff the assembly's metadata mentions /// Java.Interop.JniAddNativeMethodRegistrationAttribute (as a @@ -77,6 +83,7 @@ sealed class AssemblyIndex : IDisposable valueTypeReferences = new TypeRefData? [reader.TypeReferences.Count + 1]; Reader = reader; AssemblyName = assemblyName; + MetadataAssemblyName = reader.GetString (reader.GetAssemblyDefinition ().Name); AssemblyPath = assemblyPath; TypeRefSignatureProvider = new TypeRefSignatureTypeProvider (this); } @@ -107,7 +114,12 @@ void Build () foreach (var exportedTypeHandle in Reader.ExportedTypes) { var exportedType = Reader.GetExportedType (exportedTypeHandle); - ExportedTypeNames.Add (GetExportedTypeFullName (exportedType)); + var fullName = GetExportedTypeFullName (exportedType); + ExportedTypeNames.Add (fullName); + var forwardedAssemblyName = GetForwardedAssemblyName (exportedType); + if (forwardedAssemblyName is not null) { + ForwardedTypeAssemblies [fullName] = forwardedAssemblyName; + } } foreach (var typeHandle in Reader.TypeDefinitions) { @@ -146,6 +158,18 @@ string GetExportedTypeFullName (ExportedType exportedType) var ns = Reader.GetString (exportedType.Namespace); return MetadataTypeNameResolver.JoinNamespaceAndName (ns, name); } + + string? GetForwardedAssemblyName (ExportedType exportedType) + { + if (exportedType.Implementation.Kind == HandleKind.AssemblyReference) { + var assemblyReference = Reader.GetAssemblyReference ((AssemblyReferenceHandle) exportedType.Implementation); + return Reader.GetString (assemblyReference.Name); + } + if (exportedType.Implementation.Kind == HandleKind.ExportedType) { + return GetForwardedAssemblyName (Reader.GetExportedType ((ExportedTypeHandle) exportedType.Implementation)); + } + return null; + } } (RegisterInfo? register, TypeAttributeInfo? attrs) ParseAttributes (TypeDefinition typeDef) diff --git a/src/Microsoft.Android.Sdk.TrimmableTypeMap/Scanner/JavaPeerScanner.cs b/src/Microsoft.Android.Sdk.TrimmableTypeMap/Scanner/JavaPeerScanner.cs index 291a2d79a7e..d2040283ee0 100644 --- a/src/Microsoft.Android.Sdk.TrimmableTypeMap/Scanner/JavaPeerScanner.cs +++ b/src/Microsoft.Android.Sdk.TrimmableTypeMap/Scanner/JavaPeerScanner.cs @@ -61,15 +61,36 @@ internal JavaPeerScanner (string? packageNamingPolicy, ITrimmableTypeMapLogger? /// bool TryResolveType (string typeName, string assemblyName, out TypeDefinitionHandle handle, [NotNullWhen (true)] out AssemblyIndex? resolvedIndex) { - if (assemblyCache.TryGetValue (assemblyName, out resolvedIndex) && - resolvedIndex.TypesByFullName.TryGetValue (typeName, out handle)) { - return true; + var visitedAssemblies = new HashSet (StringComparer.Ordinal); + while (visitedAssemblies.Add (assemblyName) && + TryGetAssemblyIndex (assemblyName, out resolvedIndex)) { + if (resolvedIndex.TypesByFullName.TryGetValue (typeName, out handle)) { + return true; + } + if (!resolvedIndex.ForwardedTypeAssemblies.TryGetValue (typeName, out assemblyName)) { + break; + } } handle = default; resolvedIndex = null; return false; } + bool TryGetAssemblyIndex (string assemblyName, [NotNullWhen (true)] out AssemblyIndex? index) + { + if (assemblyCache.TryGetValue (assemblyName, out index)) { + return true; + } + foreach (var candidate in assemblyCache.Values) { + if (string.Equals (candidate.MetadataAssemblyName, assemblyName, StringComparison.Ordinal)) { + index = candidate; + return true; + } + } + index = null; + return false; + } + /// /// Resolves the type that declares the native n_* callback. When the [Register] connector /// names a declaring type (e.g. an *Invoker in another assembly) that type is used; @@ -808,9 +829,7 @@ bool ValidateExportSignature (MethodDefinition methodDef, AssemblyIndex index, b } var sig = methodDef.DecodeSignature (TypeRefSignatureTypeProvider.Instance, index); - var (parameterKinds, returnKind) = isExport - ? GetExportParameterKinds (methodDef, index, sig.ParameterTypes.Length) - : (CreateDefaultExportKinds (sig.ParameterTypes.Length), ExportParameterKindInfo.Unspecified); + var (parameterKinds, returnKind) = GetExportParameterKinds (methodDef, index, sig.ParameterTypes.Length); var declaringType = index.Reader.GetTypeDefinition (methodDef.GetDeclaringType ()); string declaringTypeName = MetadataTypeNameResolver.GetFullName (declaringType, index.Reader); string memberName = $"{declaringTypeName}.{methodName}"; @@ -1202,32 +1221,47 @@ void CollectBaseConstructorChain (TypeDefinition typeDef, AssemblyIndex index, } /// - /// Looks up a managed type name across loaded assemblies. If the type has + /// Looks up a managed type in its referenced assembly. If the type has /// [Register], returns "L<jniName>;". Otherwise returns null. /// + string? TryResolveJniObjectDescriptor (TypeRefData managedType) + { + if (!TryResolveType (managedType.ManagedTypeName, managedType.AssemblyName, out var handle, out var index)) { + return null; + } + return GetJniObjectDescriptor (handle, index); + } + + /// + /// Looks up an unqualified managed type name across loaded assemblies. + /// Used only by legacy-compatible constructor signature discovery. + /// string? TryResolveJniObjectDescriptor (string managedType) { foreach (var index in assemblyCache.Values) { if (index.TypesByFullName.TryGetValue (managedType, out var handle)) { - if (index.RegisterInfoByType.TryGetValue (handle, out var registerInfo)) { - return $"L{registerInfo.JniName};"; - } - - // User peer types (extend a Java peer but lack [Register]) - // get a CRC64-based JNI name in ScanAssembly. Mirror that here - // so [Export]/[ExportField] signatures referring to such types - // emit the correct peer descriptor instead of falling back to - // java/lang/Object. - var typeDef = index.Reader.GetTypeDefinition (handle); - if (ExtendsJavaPeer (handle, typeDef, index)) { - var (jniName, _) = ComputeAutoJniNames (typeDef, index); - return $"L{jniName};"; - } + return GetJniObjectDescriptor (handle, index); } } return null; } + string? GetJniObjectDescriptor (TypeDefinitionHandle handle, AssemblyIndex index) + { + if (index.RegisterInfoByType.TryGetValue (handle, out var registerInfo)) { + return $"L{registerInfo.JniName};"; + } + + // User peer types (extend a Java peer but lack [Register]) get a CRC64-based + // JNI name in ScanAssembly. Mirror that for exported signatures. + var typeDef = index.Reader.GetTypeDefinition (handle); + if (ExtendsJavaPeer (typeDef, index)) { + var (jniName, _) = ComputeAutoJniNames (typeDef, index); + return $"L{jniName};"; + } + return null; + } + /// /// Resolves a `typeof(X)` argument captured as an assembly-qualified name /// (e.g. "Java.IO.IOException, Mono.Android, ...") to its JNI internal @@ -2018,11 +2052,18 @@ string BuildJniSignatureFromManaged (MethodSignature sig, IReadOnly { var managedName = index.Reader.GetString (methodDef.Name); var sig = methodDef.DecodeSignature (index.TypeRefSignatureProvider, index); - var jniSig = BuildJniSignatureFromManaged (sig, GetDefaultExportKinds (sig.ParameterTypes.Length), ExportParameterKindInfo.Unspecified); + var (parameterKinds, returnKind) = GetExportParameterKinds (methodDef, index, sig.ParameterTypes.Length); + var jniSig = BuildJniSignatureFromManaged (sig, parameterKinds, returnKind); return ( new RegisterInfo { JniName = managedName, Signature = jniSig, Connector = "__export__", DoNotGenerateAcw = false }, - new ExportInfo { ThrownNames = null, SuperArgumentsString = null, IsField = true } + new ExportInfo { + ThrownNames = null, + SuperArgumentsString = null, + IsField = true, + ParameterKinds = parameterKinds, + ReturnKind = returnKind, + } ); } @@ -2043,23 +2084,6 @@ bool TryManagedTypeToJniDescriptor ( ExportParameterKindInfo exportKind, out string descriptor) { - if (exportKind != ExportParameterKindInfo.Unspecified) { - descriptor = exportKind switch { - ExportParameterKindInfo.InputStream => "Ljava/io/InputStream;", - ExportParameterKindInfo.OutputStream => "Ljava/io/OutputStream;", - ExportParameterKindInfo.XmlPullParser => "Lorg/xmlpull/v1/XmlPullParser;", - ExportParameterKindInfo.XmlResourceParser => "Landroid/content/res/XmlResourceParser;", - _ => "Ljava/lang/Object;", - }; - return true; - } - - var primitive = TryGetPrimitiveJniDescriptor (managedType.ManagedTypeName); - if (primitive is not null) { - descriptor = primitive; - return true; - } - if (managedType.ManagedTypeName.EndsWith ("[]", StringComparison.Ordinal)) { var elementType = managedType with { ManagedTypeName = managedType.ManagedTypeName.Substring (0, managedType.ManagedTypeName.Length - 2), @@ -2072,8 +2096,18 @@ bool TryManagedTypeToJniDescriptor ( return false; } + if (exportKind != ExportParameterKindInfo.Unspecified) { + return TryGetExportParameterDescriptor (managedType.ManagedTypeName, exportKind, out descriptor); + } + + var primitive = TryGetPrimitiveJniDescriptor (managedType.ManagedTypeName); + if (primitive is not null) { + descriptor = primitive; + return true; + } + // Try to resolve as a Java peer type with [Register] - var resolved = TryResolveJniObjectDescriptor (managedType.ManagedTypeName); + var resolved = TryResolveJniObjectDescriptor (managedType); if (resolved is not null) { descriptor = resolved; return true; @@ -2108,6 +2142,21 @@ bool TryManagedTypeToJniDescriptor ( return false; } + static bool TryGetExportParameterDescriptor ( + string managedTypeName, + ExportParameterKindInfo exportKind, + out string descriptor) + { + descriptor = exportKind switch { + ExportParameterKindInfo.InputStream when managedTypeName == "System.IO.Stream" => "Ljava/io/InputStream;", + ExportParameterKindInfo.OutputStream when managedTypeName == "System.IO.Stream" => "Ljava/io/OutputStream;", + ExportParameterKindInfo.XmlPullParser when managedTypeName == "System.Xml.XmlReader" => "Lorg/xmlpull/v1/XmlPullParser;", + ExportParameterKindInfo.XmlResourceParser when managedTypeName == "System.Xml.XmlReader" => "Landroid/content/res/XmlResourceParser;", + _ => "", + }; + return descriptor.Length > 0; + } + /// /// Returns the JNI descriptor for primitive types and System.String. /// Returns null for all other types. @@ -2771,7 +2820,8 @@ void CollectExportField (MethodDefinition methodDef, AssemblyIndex index, List 0;""", "unsupported", ""), + "mismatched-export-parameter" => ( + "public sealed class ManagedOnly { }", + """ + [Export ("unsupported")] + public ManagedOnly UnsupportedMember ( + [ExportParameter (ExportParameterKind.InputStream)] ManagedOnly value) + => value; + """, + "unsupported", + ""), + "generic-export-parameter" => ( + "", + """ + [Export ("unsupported")] + public T UnsupportedMember ( + [ExportParameter (ExportParameterKind.InputStream)] T value) + => value; + """, + "unsupported", + ""), + "function-pointer-export-parameter" => ( + "", + """ + [Export ("unsupported")] + public unsafe delegate* unmanaged UnsupportedMember ( + [ExportParameter (ExportParameterKind.InputStream)] delegate* unmanaged value) + => value; + """, + "unsupported", + ""), + "mismatched-field-export-parameter" => ( + "public sealed class ManagedOnly { }", + """ + [return: ExportParameter (ExportParameterKind.OutputStream)] + [ExportField ("UNSUPPORTED_FIELD")] + public ManagedOnly UnsupportedMember () => new (); + """, + "UNSUPPORTED_FIELD", + ""), _ => throw new InvalidOperationException ($"Unknown unsupported [Export] shape '{invalidShape}'."), }; var proj = new XamarinAndroidApplicationProject { diff --git a/tests/Microsoft.Android.Sdk.TrimmableTypeMap.IntegrationTests/ScannerExportShapesTests.cs b/tests/Microsoft.Android.Sdk.TrimmableTypeMap.IntegrationTests/ScannerExportShapesTests.cs index 04d9f4eb1cf..5ccddc99ad0 100644 --- a/tests/Microsoft.Android.Sdk.TrimmableTypeMap.IntegrationTests/ScannerExportShapesTests.cs +++ b/tests/Microsoft.Android.Sdk.TrimmableTypeMap.IntegrationTests/ScannerExportShapesTests.cs @@ -32,12 +32,14 @@ static MarshalMethodInfo[] GetMarshalMethods (string javaName) return GetPeer (javaName).MarshalMethods.ToArray (); } - static JavaPeerInfo GetPeer (string javaName) + static JavaPeerInfo GetPeer (string javaName) => GetPeer (javaName, UserTypesFixturePath); + + static JavaPeerInfo GetPeer (string javaName, params string [] fixturePaths) { - var fixturePath = UserTypesFixturePath; + var fixturePath = fixturePaths [0]; var dir = AssertNotNull (Path.GetDirectoryName (fixturePath)); - var paths = new System.Collections.Generic.List { fixturePath }; + var paths = new System.Collections.Generic.List (fixturePaths); var monoAndroid = Path.Combine (dir, "Mono.Android.dll"); var javaInterop = Path.Combine (dir, "Java.Interop.dll"); if (File.Exists (monoAndroid)) @@ -104,6 +106,23 @@ public void ExportField_RegistersGetterAsMarshalMethod () AssertHasExport (methods, "GetValue", "()Ljava/lang/String;"); AssertHasExport (methods, "GetCount", "()I"); + AssertHasExport (methods, "GetOutputStream", "()Ljava/io/OutputStream;"); + AssertHasExport (methods, "GetXmlParser", "()Lorg/xmlpull/v1/XmlPullParser;"); + + var peer = GetPeer ("ExportFieldShapes"); + Assert.Contains (peer.JavaFields, field => field.FieldName == "OUTPUT_STREAM" && field.JavaTypeName == "java.io.OutputStream"); + Assert.Contains (peer.JavaFields, field => field.FieldName == "XML_PARSER" && field.JavaTypeName == "org.xmlpull.v1.XmlPullParser"); + } + + [Fact] + public void Export_CrossAssemblySameManagedName_DoesNotBorrowPeerDescriptor () + { + var directory = AssertNotNull (Path.GetDirectoryName (UserTypesFixturePath)); + var javaSourceFixturePath = Path.Combine (directory, "JavaSourceParityFixture.dll"); + Assert.True (File.Exists (javaSourceFixturePath), $"JavaSourceParityFixture.dll not found at '{javaSourceFixturePath}'."); + + var peer = GetPeer ("ExportAssemblyCollisionShape", javaSourceFixturePath, UserTypesFixturePath); + Assert.DoesNotContain (peer.MarshalMethods, method => method.ManagedMethodName == "UnsupportedCollision"); } // === Phase A: dispatch & declaration shapes === diff --git a/tests/Microsoft.Android.Sdk.TrimmableTypeMap.IntegrationTests/UserTypesFixture/UserTypes.cs b/tests/Microsoft.Android.Sdk.TrimmableTypeMap.IntegrationTests/UserTypesFixture/UserTypes.cs index df25fc4c28e..a522c81c155 100644 --- a/tests/Microsoft.Android.Sdk.TrimmableTypeMap.IntegrationTests/UserTypesFixture/UserTypes.cs +++ b/tests/Microsoft.Android.Sdk.TrimmableTypeMap.IntegrationTests/UserTypesFixture/UserTypes.cs @@ -209,6 +209,14 @@ protected ExportFieldShapes (IntPtr handle, JniHandleOwnership transfer) : base [ExportField ("COUNT")] public int GetCount () => 0; + + [return: ExportParameter (ExportParameterKind.OutputStream)] + [ExportField ("OUTPUT_STREAM")] + public System.IO.Stream? GetOutputStream () => null; + + [return: ExportParameter (ExportParameterKind.XmlPullParser)] + [ExportField ("XML_PARSER")] + public System.Xml.XmlReader? GetXmlParser () => null; } // [ExportParameter] overrides a Stream / XmlReader's Java type without @@ -394,3 +402,20 @@ public class ExportInterfaceRenameShape : Java.Lang.Object, Android.Views.View.I public void OnClick (Android.Views.View? v) { } } } + +namespace UserApp.JavaSourceParity +{ + public class SignatureCollision + { + } +} + +namespace UserApp +{ + [Register ("com/example/userapp/ExportAssemblyCollisionShape")] + public class ExportAssemblyCollisionShape : Java.Lang.Object + { + [Export ("unsupportedCollision")] + public void UnsupportedCollision (JavaSourceParity.SignatureCollision value) { } + } +} diff --git a/tests/Microsoft.Android.Sdk.TrimmableTypeMap.Tests/Generator/ExportFieldTests.cs b/tests/Microsoft.Android.Sdk.TrimmableTypeMap.Tests/Generator/ExportFieldTests.cs index 1f84df6b278..1a22a78036e 100644 --- a/tests/Microsoft.Android.Sdk.TrimmableTypeMap.Tests/Generator/ExportFieldTests.cs +++ b/tests/Microsoft.Android.Sdk.TrimmableTypeMap.Tests/Generator/ExportFieldTests.cs @@ -25,6 +25,18 @@ public void Scanner_DetectsExportFieldsWithCorrectProperties () Assert.False (instanceField.IsStatic); Assert.Equal ("GetValue", instanceField.InitializerMethodName); Assert.Equal ("java.lang.String", instanceField.JavaTypeName); + + var streamField = peer.JavaFields.First (f => f.FieldName == "OUTPUT_STREAM"); + Assert.Equal ("java.io.OutputStream", streamField.JavaTypeName); + var streamMethod = peer.MarshalMethods.First (m => m.ManagedMethodName == "GetOutputStream"); + Assert.Equal ("()Ljava/io/OutputStream;", streamMethod.JniSignature); + Assert.Equal (ExportParameterKindInfo.OutputStream, streamMethod.ManagedReturnExportKind); + + var xmlField = peer.JavaFields.First (f => f.FieldName == "XML_PARSER"); + Assert.Equal ("org.xmlpull.v1.XmlPullParser", xmlField.JavaTypeName); + var xmlMethod = peer.MarshalMethods.First (m => m.ManagedMethodName == "GetXmlParser"); + Assert.Equal ("()Lorg/xmlpull/v1/XmlPullParser;", xmlMethod.JniSignature); + Assert.Equal (ExportParameterKindInfo.XmlPullParser, xmlMethod.ManagedReturnExportKind); } [Fact] diff --git a/tests/Microsoft.Android.Sdk.TrimmableTypeMap.Tests/Generator/ExportSignatureTests.cs b/tests/Microsoft.Android.Sdk.TrimmableTypeMap.Tests/Generator/ExportSignatureTests.cs index b092903f13f..bfd889fd450 100644 --- a/tests/Microsoft.Android.Sdk.TrimmableTypeMap.Tests/Generator/ExportSignatureTests.cs +++ b/tests/Microsoft.Android.Sdk.TrimmableTypeMap.Tests/Generator/ExportSignatureTests.cs @@ -11,6 +11,9 @@ public class ExportSignatureTests : FixtureTestBase [InlineData ("my/app/ExportFieldWithUnsupportedManagedReturn")] [InlineData ("my/app/ExportWithGenericMethodParameter")] [InlineData ("my/app/ExportWithGenericInstantiation")] + [InlineData ("my/app/ExportWithInvalidExportParameterType")] + [InlineData ("my/app/ExportWithGenericExportParameter")] + [InlineData ("my/app/ExportFieldWithInvalidExportParameterType")] [InlineData ("my/app/GenericExportType")] public void ScannerAndGenerator_UnsupportedExportSignatureProducesNoMember (string javaName) { diff --git a/tests/Microsoft.Android.Sdk.TrimmableTypeMap.Tests/Generator/TrimmableTypeMapGeneratorTests.cs b/tests/Microsoft.Android.Sdk.TrimmableTypeMap.Tests/Generator/TrimmableTypeMapGeneratorTests.cs index b939dc8407d..2623d70e894 100644 --- a/tests/Microsoft.Android.Sdk.TrimmableTypeMap.Tests/Generator/TrimmableTypeMapGeneratorTests.cs +++ b/tests/Microsoft.Android.Sdk.TrimmableTypeMap.Tests/Generator/TrimmableTypeMapGeneratorTests.cs @@ -356,7 +356,7 @@ public void Execute_UnsupportedExportSignatures_ReportCodedDiagnosticsWithoutPar using var peReader = CreateTestFixturePEReader (); var result = CreateGenerator ().Execute ([Input ("TestFixtures", peReader)], new Version (11, 0), new HashSet ()); - Assert.Equal (5, logMessages.Count (message => message.StartsWith ("XA4263:", StringComparison.Ordinal))); + Assert.Equal (8, logMessages.Count (message => message.StartsWith ("XA4263:", StringComparison.Ordinal))); Assert.Equal (1, logMessages.Count (message => message.StartsWith ("XA4206:", StringComparison.Ordinal))); foreach (var javaName in new [] { "my/app/ExportWithUnsupportedManagedParameter", @@ -364,6 +364,9 @@ public void Execute_UnsupportedExportSignatures_ReportCodedDiagnosticsWithoutPar "my/app/ExportFieldWithUnsupportedManagedReturn", "my/app/ExportWithGenericMethodParameter", "my/app/ExportWithGenericInstantiation", + "my/app/ExportWithInvalidExportParameterType", + "my/app/ExportWithGenericExportParameter", + "my/app/ExportFieldWithInvalidExportParameterType", "my/app/GenericExportType", }) { var peer = result.AllPeers.Single (candidate => candidate.JavaName == javaName); diff --git a/tests/Microsoft.Android.Sdk.TrimmableTypeMap.Tests/TestFixtures/TestTypes.cs b/tests/Microsoft.Android.Sdk.TrimmableTypeMap.Tests/TestFixtures/TestTypes.cs index 2e70958ba64..d749680077b 100644 --- a/tests/Microsoft.Android.Sdk.TrimmableTypeMap.Tests/TestFixtures/TestTypes.cs +++ b/tests/Microsoft.Android.Sdk.TrimmableTypeMap.Tests/TestFixtures/TestTypes.cs @@ -619,6 +619,32 @@ public class ExportWithGenericInstantiation : Java.Lang.Object public System.Collections.Generic.List UnsupportedMember (System.Collections.Generic.List value) => value; } + [Register ("my/app/ExportWithInvalidExportParameterType")] + public class ExportWithInvalidExportParameterType : Java.Lang.Object + { + [Java.Interop.Export ("unsupported")] + public UnsupportedExportValue UnsupportedMember ( + [Java.Interop.ExportParameter (Java.Interop.ExportParameterKind.InputStream)] UnsupportedExportValue value) + => value; + } + + [Register ("my/app/ExportWithGenericExportParameter")] + public class ExportWithGenericExportParameter : Java.Lang.Object + { + [Java.Interop.Export ("unsupported")] + public T UnsupportedMember ( + [Java.Interop.ExportParameter (Java.Interop.ExportParameterKind.InputStream)] T value) + => value; + } + + [Register ("my/app/ExportFieldWithInvalidExportParameterType")] + public class ExportFieldWithInvalidExportParameterType : Java.Lang.Object + { + [return: Java.Interop.ExportParameter (Java.Interop.ExportParameterKind.OutputStream)] + [Java.Interop.ExportField ("UNSUPPORTED_FIELD")] + public UnsupportedExportValue UnsupportedMember () => new (); + } + [Register ("my/app/GenericExportType")] public class GenericExportType : Java.Lang.Object { @@ -662,6 +688,14 @@ protected ExportFieldExample (IntPtr handle, JniHandleOwnership transfer) : base [Java.Interop.ExportField ("VALUE")] [JavaAnnotation] public string GetValue () => ""; + + [return: Java.Interop.ExportParameter (Java.Interop.ExportParameterKind.OutputStream)] + [Java.Interop.ExportField ("OUTPUT_STREAM")] + public Stream? GetOutputStream () => null; + + [return: Java.Interop.ExportParameter (Java.Interop.ExportParameterKind.XmlPullParser)] + [Java.Interop.ExportField ("XML_PARSER")] + public XmlReader? GetXmlParser () => null; } [Register ("my/app/BaseInstrumentation")] From 59f9b73e118d6ccc9e6043d1bcb0aac158b447be Mon Sep 17 00:00:00 2001 From: Simon Rozsival Date: Mon, 31 Aug 2026 12:18:19 +0200 Subject: [PATCH 03/14] [typemap] Validate scalar export mappings Require special ExportParameter mappings to target exact scalar Stream or XmlReader types, and match Export, ExportParameter, and ExportField attributes by full Java.Interop identity throughout scanner validation and collection. Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com> --- Documentation/docs-mobile/messages/xa4263.md | 1 + .../Scanner/AssemblyIndex.cs | 2 - .../Scanner/JavaPeerScanner.cs | 31 +++++++--- .../TrimmableTypeMapBuildTests.cs | 62 ++++++++++++++++++- .../Generator/ExportSignatureTests.cs | 18 ++++++ .../TestFixtures/StubAttributes.cs | 21 +++++++ .../TestFixtures/TestTypes.cs | 15 +++++ 7 files changed, 136 insertions(+), 14 deletions(-) diff --git a/Documentation/docs-mobile/messages/xa4263.md b/Documentation/docs-mobile/messages/xa4263.md index 3da646d645d..c672ebf7228 100644 --- a/Documentation/docs-mobile/messages/xa4263.md +++ b/Documentation/docs-mobile/messages/xa4263.md @@ -24,3 +24,4 @@ This error also occurs when `[ExportParameter]` specifies a Java mapping that is Use a primitive, string, array, Java peer, or another supported managed-to-Java type. Apply input/output stream mappings only to `Stream`, and XML parser mappings only to `XmlReader`. +Do not apply these scalar mappings to arrays or other wrappers around those types. diff --git a/src/Microsoft.Android.Sdk.TrimmableTypeMap/Scanner/AssemblyIndex.cs b/src/Microsoft.Android.Sdk.TrimmableTypeMap/Scanner/AssemblyIndex.cs index b0182877d6a..30e340ef367 100644 --- a/src/Microsoft.Android.Sdk.TrimmableTypeMap/Scanner/AssemblyIndex.cs +++ b/src/Microsoft.Android.Sdk.TrimmableTypeMap/Scanner/AssemblyIndex.cs @@ -197,8 +197,6 @@ string GetExportedTypeFullName (ExportedType exportedType) registerInfo = registerInfo with { JniName = registerInfo.JniName.Replace ('.', '/') }; } else if (attrName == "JniTypeSignatureAttribute") { registerInfo = ParseJniTypeSignatureAttribute (ca); - } else if (attrName == "ExportAttribute") { - // [Export] is a method-level attribute; it is parsed at scan time by JavaPeerScanner } else if (IsKnownComponentAttribute (attrName)) { attrInfo ??= CreateTypeAttributeInfo (attrName); var value = DecodeAttribute (ca); diff --git a/src/Microsoft.Android.Sdk.TrimmableTypeMap/Scanner/JavaPeerScanner.cs b/src/Microsoft.Android.Sdk.TrimmableTypeMap/Scanner/JavaPeerScanner.cs index d2040283ee0..b2919f7f0dd 100644 --- a/src/Microsoft.Android.Sdk.TrimmableTypeMap/Scanner/JavaPeerScanner.cs +++ b/src/Microsoft.Android.Sdk.TrimmableTypeMap/Scanner/JavaPeerScanner.cs @@ -774,6 +774,16 @@ static bool IsExportFieldAttribute (CustomAttribute attribute, AssemblyIndex ind return AssemblyIndex.IsCustomAttributeMatch (attribute, index.Reader, "Java.Interop", "ExportFieldAttribute"); } + static bool IsExportAttribute (CustomAttribute attribute, AssemblyIndex index) + { + return AssemblyIndex.IsCustomAttributeMatch (attribute, index.Reader, "Java.Interop", "ExportAttribute"); + } + + static bool IsExportParameterAttribute (CustomAttribute attribute, AssemblyIndex index) + { + return AssemblyIndex.IsCustomAttributeMatch (attribute, index.Reader, "Java.Interop", "ExportParameterAttribute"); + } + bool ValidateExportField (MethodDefinition methodDef, AssemblyIndex index, bool isGenericType) { foreach (var caHandle in methodDef.GetCustomAttributes ()) { @@ -808,8 +818,7 @@ bool ValidateExportSignature (MethodDefinition methodDef, AssemblyIndex index, b bool isExportField = false; foreach (var caHandle in methodDef.GetCustomAttributes ()) { var ca = index.Reader.GetCustomAttribute (caHandle); - var attrName = AssemblyIndex.GetCustomAttributeName (ca, index.Reader); - if (attrName == "ExportAttribute") { + if (IsExportAttribute (ca, index)) { isExport = true; } else if (IsExportFieldAttribute (ca, index)) { isExportField = true; @@ -852,6 +861,9 @@ bool HasExportSignatureMapping (TypeRefData managedType, ExportParameterKindInfo if (TryManagedTypeToJniDescriptor (managedType, exportKind, out _)) { return true; } + if (exportKind != ExportParameterKindInfo.Unspecified) { + return false; + } // Legacy maps by-ref, pointer, and rectangular-array signatures through their // element type. Their trimmable dispatch parity is tracked separately; do not @@ -1855,7 +1867,7 @@ bool TryGetMethodRegisterInfo (MethodDefinition methodDef, AssemblyIndex index, return true; } - if (attrName == "ExportAttribute") { + if (IsExportAttribute (ca, index)) { (registerInfo, exportInfo) = ParseExportAttribute (ca, methodDef, index); return true; } @@ -1999,8 +2011,7 @@ static ExportParameterKindInfo GetExportParameterKind (Parameter parameter, Asse { foreach (var caHandle in parameter.GetCustomAttributes ()) { var ca = index.Reader.GetCustomAttribute (caHandle); - var attrName = index.GetCustomAttributeName (ca); - if (attrName != "ExportParameterAttribute") { + if (!IsExportParameterAttribute (ca, index)) { continue; } @@ -2084,11 +2095,15 @@ bool TryManagedTypeToJniDescriptor ( ExportParameterKindInfo exportKind, out string descriptor) { + if (exportKind != ExportParameterKindInfo.Unspecified) { + return TryGetExportParameterDescriptor (managedType.ManagedTypeName, exportKind, out descriptor); + } + if (managedType.ManagedTypeName.EndsWith ("[]", StringComparison.Ordinal)) { var elementType = managedType with { ManagedTypeName = managedType.ManagedTypeName.Substring (0, managedType.ManagedTypeName.Length - 2), }; - if (TryManagedTypeToJniDescriptor (elementType, exportKind, out var elementDescriptor)) { + if (TryManagedTypeToJniDescriptor (elementType, ExportParameterKindInfo.Unspecified, out var elementDescriptor)) { descriptor = $"[{elementDescriptor}"; return true; } @@ -2096,10 +2111,6 @@ bool TryManagedTypeToJniDescriptor ( return false; } - if (exportKind != ExportParameterKindInfo.Unspecified) { - return TryGetExportParameterDescriptor (managedType.ManagedTypeName, exportKind, out descriptor); - } - var primitive = TryGetPrimitiveJniDescriptor (managedType.ManagedTypeName); if (primitive is not null) { descriptor = primitive; diff --git a/src/Xamarin.Android.Build.Tasks/Tests/Xamarin.Android.Build.Tests/TrimmableTypeMapBuildTests.cs b/src/Xamarin.Android.Build.Tasks/Tests/Xamarin.Android.Build.Tests/TrimmableTypeMapBuildTests.cs index 9b0bda0d284..9af7a0c26b7 100644 --- a/src/Xamarin.Android.Build.Tasks/Tests/Xamarin.Android.Build.Tests/TrimmableTypeMapBuildTests.cs +++ b/src/Xamarin.Android.Build.Tasks/Tests/Xamarin.Android.Build.Tests/TrimmableTypeMapBuildTests.cs @@ -128,7 +128,19 @@ public void Build_InvalidExportField_ReportsLegacyDiagnostic ( [TestCase ("llvm-ir", AndroidRuntime.CoreCLR, "mismatched-field-export-parameter", "XALNS7004")] [TestCase ("trimmable", AndroidRuntime.CoreCLR, "mismatched-field-export-parameter", "XA4263")] [TestCase ("trimmable", AndroidRuntime.NativeAOT, "mismatched-field-export-parameter", "XA4263")] - public void Build_UnsupportedExportSignature_ReportsCodedDiagnosticWithoutPartialOutputs ( + [TestCase ("llvm-ir", AndroidRuntime.CoreCLR, "special-array-parameter", "success")] + [TestCase ("trimmable", AndroidRuntime.CoreCLR, "special-array-parameter", "XA4263")] + [TestCase ("trimmable", AndroidRuntime.NativeAOT, "special-array-parameter", "XA4263")] + [TestCase ("llvm-ir", AndroidRuntime.CoreCLR, "special-array-return", "success")] + [TestCase ("trimmable", AndroidRuntime.CoreCLR, "special-array-return", "XA4263")] + [TestCase ("trimmable", AndroidRuntime.NativeAOT, "special-array-return", "XA4263")] + [TestCase ("llvm-ir", AndroidRuntime.CoreCLR, "special-array-field", "success")] + [TestCase ("trimmable", AndroidRuntime.CoreCLR, "special-array-field", "XA4263")] + [TestCase ("trimmable", AndroidRuntime.NativeAOT, "special-array-field", "XA4263")] + [TestCase ("llvm-ir", AndroidRuntime.CoreCLR, "special-xml-array-return", "success")] + [TestCase ("trimmable", AndroidRuntime.CoreCLR, "special-xml-array-return", "XA4263")] + [TestCase ("trimmable", AndroidRuntime.NativeAOT, "special-xml-array-return", "XA4263")] + public void Build_ExportSignature_MatchesRuntimeClassification ( string typeMapImplementation, AndroidRuntime runtime, string invalidShape, @@ -214,6 +226,44 @@ public T UnsupportedMember ( """, "UNSUPPORTED_FIELD", ""), + "special-array-parameter" => ( + "", + """ + [Export ("unsupported")] + public void UnsupportedMember ( + [ExportParameter (ExportParameterKind.InputStream)] Stream [] value) + { + } + """, + "unsupported", + ""), + "special-array-return" => ( + "", + """ + [return: ExportParameter (ExportParameterKind.OutputStream)] + [Export ("unsupported")] + public Stream [] UnsupportedMember () => []; + """, + "unsupported", + ""), + "special-array-field" => ( + "", + """ + [return: ExportParameter (ExportParameterKind.OutputStream)] + [ExportField ("UNSUPPORTED_FIELD")] + public Stream [] UnsupportedMember () => []; + """, + "UNSUPPORTED_FIELD", + ""), + "special-xml-array-return" => ( + "", + """ + [return: ExportParameter (ExportParameterKind.XmlPullParser)] + [Export ("unsupported")] + public XmlReader [] UnsupportedMember () => []; + """, + "unsupported", + ""), _ => throw new InvalidOperationException ($"Unknown unsupported [Export] shape '{invalidShape}'."), }; var proj = new XamarinAndroidApplicationProject { @@ -228,6 +278,8 @@ public T UnsupportedMember ( proj.Sources.Add (new BuildItem.Source ("ExportSignatureValidation.cs") { TextContent = () => $$""" using System.Collections.Generic; + using System.IO; + using System.Xml; using Android.Runtime; using Java.Interop; @@ -247,7 +299,13 @@ public SignaturePeer () { using var builder = CreateApkBuilder (); builder.ThrowOnBuildFailure = false; - Assert.IsFalse (builder.Build (proj), $"{runtime}/{typeMapImplementation} should reject {invalidShape}."); + var succeeded = builder.Build (proj); + if (expectedCode == "success") { + Assert.IsTrue (succeeded, $"{runtime}/{typeMapImplementation} should retain legacy build support for {invalidShape}."); + return; + } + + Assert.IsFalse (succeeded, $"{runtime}/{typeMapImplementation} should reject {invalidShape}."); StringAssertEx.Contains ($"error {expectedCode}", builder.LastBuildOutput, $"The build should report {expectedCode}."); if (expectedCode == "XA4263") { StringAssertEx.Contains ( diff --git a/tests/Microsoft.Android.Sdk.TrimmableTypeMap.Tests/Generator/ExportSignatureTests.cs b/tests/Microsoft.Android.Sdk.TrimmableTypeMap.Tests/Generator/ExportSignatureTests.cs index bfd889fd450..726cb3a5dd9 100644 --- a/tests/Microsoft.Android.Sdk.TrimmableTypeMap.Tests/Generator/ExportSignatureTests.cs +++ b/tests/Microsoft.Android.Sdk.TrimmableTypeMap.Tests/Generator/ExportSignatureTests.cs @@ -26,4 +26,22 @@ public void ScannerAndGenerator_UnsupportedExportSignatureProducesNoMember (stri new JcwJavaSourceGenerator ().Generate (peer, writer); Assert.DoesNotContain (" unsupported (", writer.ToString (), System.StringComparison.Ordinal); } + + [Fact] + public void ScannerAndGenerator_IgnoreExportAttributeLookalikes () + { + var peer = FindFixtureByJavaName ("my/app/ExportAttributeLookalikes"); + + Assert.DoesNotContain (peer.MarshalMethods, method => method.ManagedMethodName == "LookalikeExport"); + Assert.Contains (peer.MarshalMethods, method => + method.ManagedMethodName == "RealExport" && + method.JniName == "realExport" && + method.JniSignature == "(Ljava/lang/String;)Ljava/lang/String;"); + + using var writer = new StringWriter (); + new JcwJavaSourceGenerator ().Generate (peer, writer); + var java = writer.ToString (); + Assert.DoesNotContain ("NOT_AN_EXPORT", java, System.StringComparison.Ordinal); + Assert.Contains ("realExport (java.lang.String", java, System.StringComparison.Ordinal); + } } diff --git a/tests/Microsoft.Android.Sdk.TrimmableTypeMap.Tests/TestFixtures/StubAttributes.cs b/tests/Microsoft.Android.Sdk.TrimmableTypeMap.Tests/TestFixtures/StubAttributes.cs index 88ca5b2f78b..2baf133e290 100644 --- a/tests/Microsoft.Android.Sdk.TrimmableTypeMap.Tests/TestFixtures/StubAttributes.cs +++ b/tests/Microsoft.Android.Sdk.TrimmableTypeMap.Tests/TestFixtures/StubAttributes.cs @@ -10,6 +10,27 @@ public enum JniHandleOwnership } } +namespace Lookalike +{ + [AttributeUsage (AttributeTargets.Method, AllowMultiple = false)] + public sealed class ExportAttribute : Attribute + { + public ExportAttribute (string name) { } + } + + [AttributeUsage (AttributeTargets.Parameter | AttributeTargets.ReturnValue, AllowMultiple = false)] + public sealed class ExportParameterAttribute : Attribute + { + public ExportParameterAttribute (Java.Interop.ExportParameterKind kind) { } + } + + [AttributeUsage (AttributeTargets.Method, AllowMultiple = false)] + public sealed class ExportFieldAttribute : Attribute + { + public ExportFieldAttribute (string name) { } + } +} + namespace Java.Interop { public struct JniObjectReference diff --git a/tests/Microsoft.Android.Sdk.TrimmableTypeMap.Tests/TestFixtures/TestTypes.cs b/tests/Microsoft.Android.Sdk.TrimmableTypeMap.Tests/TestFixtures/TestTypes.cs index d749680077b..85ce4d8fbed 100644 --- a/tests/Microsoft.Android.Sdk.TrimmableTypeMap.Tests/TestFixtures/TestTypes.cs +++ b/tests/Microsoft.Android.Sdk.TrimmableTypeMap.Tests/TestFixtures/TestTypes.cs @@ -652,6 +652,21 @@ public class GenericExportType : Java.Lang.Object public int UnsupportedMember () => 0; } + [Register ("my/app/ExportAttributeLookalikes")] + public class ExportAttributeLookalikes : Java.Lang.Object + { + [Lookalike.Export ("NOT_AN_EXPORT")] + public void LookalikeExport ( + [Lookalike.ExportParameter (Java.Interop.ExportParameterKind.InputStream)] UnsupportedExportValue value) + { + } + + [Java.Interop.Export ("realExport")] + public string RealExport ( + [Lookalike.ExportParameter (Java.Interop.ExportParameterKind.InputStream)] string value) + => value; + } + /// /// Has [Export] methods with different access modifiers. /// The JCW should respect the C# visibility for [Export] methods. From ce922b7bd702223efe3eed163feb9a5bb4092830 Mon Sep 17 00:00:00 2001 From: Simon Rozsival Date: Mon, 31 Aug 2026 13:17:43 +0200 Subject: [PATCH 04/14] [typemap] Validate exported constructors Ignore static exported constructors, diagnose unresolved instance constructor parameters without overlapping XA4260 shape ownership, preserve ExportParameter kinds through UCO activation, and resolve enum signatures by assembly identity. Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com> --- .../Generator/MetadataHelper.cs | 4 + .../Generator/Model/TypeMapAssemblyData.cs | 5 + .../Generator/ModelBuilder.cs | 1 + .../Generator/TypeMapAssemblyEmitter.cs | 59 +++-------- .../Scanner/JavaPeerInfo.cs | 5 + .../Scanner/JavaPeerScanner.cs | 99 ++++++++++++++----- .../TrimmableTypeMapBuildTests.cs | 59 ++++++++++- .../ScannerExportShapesTests.cs | 3 + .../UserTypesFixture/UserTypes.cs | 10 ++ .../Generator/ExportSignatureTests.cs | 63 ++++++++++++ .../TrimmableTypeMapGeneratorTests.cs | 10 +- .../TypeMapAssemblyGeneratorTests.cs | 30 ++++++ .../Generator/TypeMapModelBuilderTests.cs | 15 +++ .../TestFixtures/TestTypes.cs | 34 +++++++ 14 files changed, 324 insertions(+), 73 deletions(-) diff --git a/src/Microsoft.Android.Sdk.TrimmableTypeMap/Generator/MetadataHelper.cs b/src/Microsoft.Android.Sdk.TrimmableTypeMap/Generator/MetadataHelper.cs index 185c2637dcf..fdaca8c7f46 100644 --- a/src/Microsoft.Android.Sdk.TrimmableTypeMap/Generator/MetadataHelper.cs +++ b/src/Microsoft.Android.Sdk.TrimmableTypeMap/Generator/MetadataHelper.cs @@ -118,6 +118,10 @@ static void WriteUcoConstructor (this BinaryWriter writer, UcoConstructorData co foreach (var parameterType in constructor.ManagedParameterTypes) { writer.WriteTypeRef (parameterType); } + writer.Write (constructor.ParameterKinds.Count); + foreach (var parameterKind in constructor.ParameterKinds) { + writer.Write ((int) parameterKind); + } } static void WriteNativeRegistration (this BinaryWriter writer, NativeRegistrationData registration) diff --git a/src/Microsoft.Android.Sdk.TrimmableTypeMap/Generator/Model/TypeMapAssemblyData.cs b/src/Microsoft.Android.Sdk.TrimmableTypeMap/Generator/Model/TypeMapAssemblyData.cs index 054a44f1795..03100fa3cae 100644 --- a/src/Microsoft.Android.Sdk.TrimmableTypeMap/Generator/Model/TypeMapAssemblyData.cs +++ b/src/Microsoft.Android.Sdk.TrimmableTypeMap/Generator/Model/TypeMapAssemblyData.cs @@ -407,6 +407,11 @@ sealed record UcoConstructorData /// to the corresponding managed type before calling the user ctor. /// public IReadOnlyList ManagedParameterTypes { get; init; } = []; + + /// + /// Per-parameter [ExportParameter] kinds for constructor argument marshalling. + /// + public IReadOnlyList ParameterKinds { get; init; } = []; } /// diff --git a/src/Microsoft.Android.Sdk.TrimmableTypeMap/Generator/ModelBuilder.cs b/src/Microsoft.Android.Sdk.TrimmableTypeMap/Generator/ModelBuilder.cs index f77ee24e0b8..65d6a024180 100644 --- a/src/Microsoft.Android.Sdk.TrimmableTypeMap/Generator/ModelBuilder.cs +++ b/src/Microsoft.Android.Sdk.TrimmableTypeMap/Generator/ModelBuilder.cs @@ -380,6 +380,7 @@ static void BuildUcoConstructors (JavaPeerInfo peer, JavaPeerProxyData proxy) AssemblyName = peer.AssemblyName, }, ManagedParameterTypes = ctor.ManagedParameterTypes, + ParameterKinds = ctor.ManagedParameterExportKinds, HasMatchingManagedCtor = ctor.HasMatchingManagedCtor, }); } diff --git a/src/Microsoft.Android.Sdk.TrimmableTypeMap/Generator/TypeMapAssemblyEmitter.cs b/src/Microsoft.Android.Sdk.TrimmableTypeMap/Generator/TypeMapAssemblyEmitter.cs index 56a160a7914..4633e1df0b5 100644 --- a/src/Microsoft.Android.Sdk.TrimmableTypeMap/Generator/TypeMapAssemblyEmitter.cs +++ b/src/Microsoft.Android.Sdk.TrimmableTypeMap/Generator/TypeMapAssemblyEmitter.cs @@ -1182,7 +1182,7 @@ MethodDefinitionHandle EmitUcoConstructor (UcoConstructorData uco, JavaPeerProxy if (uco.HasMatchingManagedCtor) { var ctorRef = AddManagedCtorRef (targetTypeRef, uco.ManagedParameterTypes); var managedCtorHandle = EmitUcoConstructorBody (uco.WrapperName, encodeSig, - enc => EmitManagedConstructorActivation (enc, targetTypeRef, ctorRef, uco.ManagedParameterTypes, jniParams), + enc => EmitManagedConstructorActivation (enc, targetTypeRef, ctorRef, uco.ManagedParameterTypes, uco.ParameterKinds, jniParams), blob => EncodeUcoConstructorLocals_DefaultConstructor (blob, targetTypeRef)); AddUnmanagedCallersOnlyAttribute (managedCtorHandle); return managedCtorHandle; @@ -1278,6 +1278,7 @@ void EmitManagedConstructorActivation ( EntityHandle targetTypeRef, MemberReferenceHandle ctorRef, IReadOnlyList managedParameterTypes, + IReadOnlyList parameterKinds, IReadOnlyList jniParams) { var havePeer = enc.DefineLabel (); @@ -1303,7 +1304,8 @@ void EmitManagedConstructorActivation ( enc.MarkLabel (havePeer); enc.LoadLocal (4); for (int i = 0; i < managedParameterTypes.Count; i++) { - EmitManagedConstructorArgument (enc, managedParameterTypes [i], jniParams [i], i + 2); + var parameterKind = i < parameterKinds.Count ? parameterKinds [i] : ExportParameterKindInfo.Unspecified; + EmitManagedConstructorArgument (enc, managedParameterTypes [i], parameterKind, jniParams [i], i + 2); } enc.Call (ctorRef, managedParameterTypes.Count, isInstance: true); @@ -1383,53 +1385,14 @@ void EmitUcoConstructorBodyWithMarshal (TrackedInstructionEncoder encoder, Contr cfb.AddFinallyRegion (tryStart, finallyStart, finallyStart, afterAll); } - void EmitManagedConstructorArgument (TrackedInstructionEncoder encoder, TypeRefData managedType, JniParamKind jniKind, int argumentIndex) + void EmitManagedConstructorArgument ( + TrackedInstructionEncoder encoder, + TypeRefData managedType, + ExportParameterKindInfo exportKind, + JniParamKind jniKind, + int argumentIndex) { - if (managedType.ManagedTypeName == "System.Boolean") { - encoder.LoadArgument (argumentIndex); - encoder.LoadConstantI4 (0); - encoder.OpCode (ILOpCode.Cgt_un); - return; - } - - if (jniKind != JniParamKind.Object) { - encoder.LoadArgument (argumentIndex); - return; - } - - if (managedType.ManagedTypeName == "System.String") { - encoder.LoadArgument (argumentIndex); - encoder.LoadConstantI4 (0); // JniHandleOwnership.DoNotTransfer - encoder.Call (_jniEnvGetStringRef, parameterCount: 2, returnsValue: true); - return; - } - - if (TryGetSzArrayElementType (managedType.ManagedTypeName, out var elementType)) { - var arrayType = ResolveManagedTypeHandle (managedType.ManagedTypeName, managedType.AssemblyName); - var elementTypeHandle = ResolveManagedTypeHandle (elementType, managedType.AssemblyName); - - encoder.LoadArgument (argumentIndex); - encoder.LoadConstantI4 (0); // JniHandleOwnership.DoNotTransfer - encoder.LoadToken (elementTypeHandle); - encoder.Call (_getTypeFromHandleRef, parameterCount: 1, returnsValue: true); - encoder.Call (_jniEnvGetArrayRef, parameterCount: 3, returnsValue: true); - encoder.CastClass (arrayType); - return; - } - - encoder.LoadArgument (argumentIndex); - encoder.LoadConstantI4 (0); // JniHandleOwnership.DoNotTransfer - if (managedType.ManagedTypeName == "System.Object") { - encoder.OpCode (ILOpCode.Ldnull); - encoder.Call (_javaLangObjectGetObjectRef, parameterCount: 3, returnsValue: true); - return; - } - - var managedTypeHandle = ResolveManagedTypeHandle (managedType.ManagedTypeName, managedType.AssemblyName); - encoder.LoadToken (managedTypeHandle); - encoder.Call (_getTypeFromHandleRef, parameterCount: 1, returnsValue: true); - encoder.Call (_javaLangObjectGetObjectRef, parameterCount: 3, returnsValue: true); - encoder.CastClass (managedTypeHandle); + GetExportMethodDispatchEmitter ().LoadManagedArgument (encoder, managedType, exportKind, jniKind, argumentIndex); } EntityHandle ResolveRuntimeTypeSpec (RuntimeTypeSpec type) diff --git a/src/Microsoft.Android.Sdk.TrimmableTypeMap/Scanner/JavaPeerInfo.cs b/src/Microsoft.Android.Sdk.TrimmableTypeMap/Scanner/JavaPeerInfo.cs index 86915bff704..114856936f9 100644 --- a/src/Microsoft.Android.Sdk.TrimmableTypeMap/Scanner/JavaPeerInfo.cs +++ b/src/Microsoft.Android.Sdk.TrimmableTypeMap/Scanner/JavaPeerInfo.cs @@ -368,6 +368,11 @@ public sealed record JavaConstructorInfo /// internal IReadOnlyList ManagedParameterTypes { get; init; } = []; + /// + /// Per-parameter [ExportParameter] kinds for constructor argument marshalling. + /// + internal IReadOnlyList ManagedParameterExportKinds { get; init; } = []; + /// /// True when this Java constructor has a matching public managed constructor on the target type. /// diff --git a/src/Microsoft.Android.Sdk.TrimmableTypeMap/Scanner/JavaPeerScanner.cs b/src/Microsoft.Android.Sdk.TrimmableTypeMap/Scanner/JavaPeerScanner.cs index b2919f7f0dd..88a042b043f 100644 --- a/src/Microsoft.Android.Sdk.TrimmableTypeMap/Scanner/JavaPeerScanner.cs +++ b/src/Microsoft.Android.Sdk.TrimmableTypeMap/Scanner/JavaPeerScanner.cs @@ -698,6 +698,10 @@ static void SkipArrayShape (ref BlobReader reader) // Pass 1: collect methods with [Register], [Export], or [ExportField] directly on them foreach (var methodHandle in typeDef.GetMethods ()) { var methodDef = index.Reader.GetMethodDefinition (methodHandle); + var methodName = index.Reader.GetString (methodDef.Name); + if (methodName == ".cctor" && (methodDef.Attributes & MethodAttributes.Static) != 0) { + continue; + } if (!ValidateExportField (methodDef, index, isGenericType)) { continue; @@ -829,10 +833,11 @@ bool ValidateExportSignature (MethodDefinition methodDef, AssemblyIndex index, b } var methodName = index.Reader.GetString (methodDef.Name); - if (methodName is ".ctor" or ".cctor") { + bool isConstructor = methodName == ".ctor"; + if (isConstructor && !isExport) { return true; } - if (isExport && isGenericType) { + if (!isConstructor && isExport && isGenericType) { logger?.LogExportOnGenericTypeError (); return false; } @@ -841,14 +846,22 @@ bool ValidateExportSignature (MethodDefinition methodDef, AssemblyIndex index, b var (parameterKinds, returnKind) = GetExportParameterKinds (methodDef, index, sig.ParameterTypes.Length); var declaringType = index.Reader.GetTypeDefinition (methodDef.GetDeclaringType ()); string declaringTypeName = MetadataTypeNameResolver.GetFullName (declaringType, index.Reader); - string memberName = $"{declaringTypeName}.{methodName}"; + string memberName = methodName [0] == '.' + ? declaringTypeName + methodName + : $"{declaringTypeName}.{methodName}"; for (int i = 0; i < sig.ParameterTypes.Length; i++) { + if (isConstructor && IsOwnedByConstructorDiagnostics (sig.ParameterTypes [i])) { + continue; + } if (!HasExportSignatureMapping (sig.ParameterTypes [i], parameterKinds [i])) { logger?.LogUnsupportedExportSignatureError (memberName, sig.ParameterTypes [i].DisplayName); return false; } } + if (isConstructor) { + return true; + } if (!HasExportSignatureMapping (sig.ReturnType, returnKind)) { logger?.LogUnsupportedExportSignatureError (memberName, sig.ReturnType.DisplayName); return false; @@ -856,6 +869,22 @@ bool ValidateExportSignature (MethodDefinition methodDef, AssemblyIndex index, b return true; } + /// + /// PR #12567 owns XA4260 for signature shapes that no Java constructor can represent. + /// This layer only adds XA4263 for unresolved types and invalid [ExportParameter] pairs. + /// + internal static bool IsOwnedByConstructorDiagnostics (TypeRefData parameterType) + { + string managedTypeName = parameterType.ManagedTypeName; + return parameterType.GenericArguments.Count > 0 || + managedTypeName.StartsWith ("!", StringComparison.Ordinal) || + managedTypeName == "delegate*" || + managedTypeName.EndsWith ("&", StringComparison.Ordinal) || + managedTypeName.EndsWith ("*", StringComparison.Ordinal) || + (managedTypeName.EndsWith ("]", StringComparison.Ordinal) && + !managedTypeName.EndsWith ("[]", StringComparison.Ordinal)); + } + bool HasExportSignatureMapping (TypeRefData managedType, ExportParameterKindInfo exportKind) { if (TryManagedTypeToJniDescriptor (managedType, exportKind, out _)) { @@ -1324,17 +1353,12 @@ bool IsEnumOrEnumArray (string managedType, string? assemblyName = null) (TypeDefinition typeDef, AssemblyIndex index)? TryFindEnumTypeDefinition (string managedType, string? assemblyName = null) { - // Prefer the typed assembly hint so two assemblies with same-named types - // (one enum, one not) resolve deterministically — assemblyCache - // enumeration order is non-deterministic. - if (assemblyName is { Length: > 0 } && - assemblyCache.TryGetValue (assemblyName, out var hintedIndex) && - hintedIndex.TypesByFullName.TryGetValue (managedType, out var hintedHandle)) { - var hintedDef = hintedIndex.Reader.GetTypeDefinition (hintedHandle); - if (IsEnumType (hintedDef, hintedIndex)) { - return (hintedDef, hintedIndex); + if (assemblyName is { Length: > 0 }) { + if (!TryResolveType (managedType, assemblyName, out var resolvedHandle, out var resolvedIndex)) { + return null; } - // Hinted assembly had a same-named non-enum; keep scanning. + var resolvedType = resolvedIndex.Reader.GetTypeDefinition (resolvedHandle); + return IsEnumType (resolvedType, resolvedIndex) ? (resolvedType, resolvedIndex) : null; } foreach (var index in assemblyCache.Values) { @@ -2729,7 +2753,10 @@ List BuildJavaConstructors (List marshal // Unsupported managed parameter shapes fail in model building for [Export] // constructors; non-[Export] registrations keep the legacy activation fallback. publicConstructors ??= GetSupportedPublicConstructors (typeDef, index); - var managedParams = TryGetMatchingPublicConstructorParameterTypes (publicConstructors, mm.JniSignature); + var managedParams = TryGetMatchingPublicConstructorParameterTypes ( + publicConstructors, + mm.JniSignature, + mm.ManagedParameterExportKinds); ctors.Add (new JavaConstructorInfo { JniSignature = mm.JniSignature, ConstructorIndex = ctorIndex, @@ -2738,6 +2765,7 @@ List BuildJavaConstructors (List marshal HasMatchingManagedCtor = managedParams != null, ManagedParameterTypes = managedParams ?? [], Annotations = mm.Annotations, + ManagedParameterExportKinds = mm.ManagedParameterExportKinds, }); ctorIndex++; } @@ -2758,10 +2786,7 @@ List GetSupportedPublicConstructors (TypeDefinition typeD var sig = methodDef.DecodeSignature (index.TypeRefSignatureProvider, genericContext: index); bool unsupported = false; foreach (var parameter in sig.ParameterTypes) { - var typeName = parameter.ManagedTypeName; - if (parameter.GenericArguments.Count > 0 || - typeName.EndsWith ("&", StringComparison.Ordinal) || - typeName.EndsWith ("*", StringComparison.Ordinal)) { + if (IsOwnedByConstructorDiagnostics (parameter)) { unsupported = true; break; } @@ -2785,27 +2810,55 @@ List GetSupportedPublicConstructors (TypeDefinition typeD /// parameter types. Returns when no compatible /// constructor exists. /// - static IReadOnlyList? TryGetMatchingPublicConstructorParameterTypes ( + IReadOnlyList? TryGetMatchingPublicConstructorParameterTypes ( List publicConstructors, - string jniSignature) + string jniSignature, + IReadOnlyList parameterKinds) { int closeParen = jniSignature.IndexOf (')'); if (closeParen < 0) { throw new ArgumentException ($"Malformed JNI signature '{jniSignature}': missing ')'"); } int parameterSignatureLength = closeParen + 1; + var jniParams = parameterKinds.Any (kind => kind != ExportParameterKindInfo.Unspecified) + ? JniSignatureHelper.ParseParameters (jniSignature) + : null; foreach (var constructor in publicConstructors) { - if (constructor.JniParameterSignature.Length != parameterSignatureLength || - string.CompareOrdinal (jniSignature, 0, constructor.JniParameterSignature, 0, parameterSignatureLength) != 0) { + if (jniParams is null) { + if (constructor.JniParameterSignature.Length != parameterSignatureLength || + string.CompareOrdinal (jniSignature, 0, constructor.JniParameterSignature, 0, parameterSignatureLength) != 0) { + continue; + } + } else if (!ManagedConstructorParametersMatchJniSignature (constructor.ParameterTypes, parameterKinds, jniParams)) { continue; } // If multiple overloads with the same JNI-compatible signature exist, match // the first public constructor in metadata order, like TypeManager.Activate. - return [.. constructor.ParameterTypes]; + return constructor.ParameterTypes; } return null; } + bool ManagedConstructorParametersMatchJniSignature ( + IReadOnlyList managedParams, + IReadOnlyList parameterKinds, + IReadOnlyList jniParams) + { + if (managedParams.Count != jniParams.Count) { + return false; + } + + for (int i = 0; i < managedParams.Count; i++) { + var parameterKind = i < parameterKinds.Count ? parameterKinds [i] : ExportParameterKindInfo.Unspecified; + var managedDescriptor = ManagedTypeToJniDescriptor (managedParams [i], parameterKind); + if (!string.Equals (managedDescriptor, jniParams [i].JniType, StringComparison.Ordinal)) { + return false; + } + } + return true; + } + } + /// /// Checks a single method for [ExportField] and adds a JavaFieldInfo if found. /// Called inline during Pass 1 to avoid a separate iteration. diff --git a/src/Xamarin.Android.Build.Tasks/Tests/Xamarin.Android.Build.Tests/TrimmableTypeMapBuildTests.cs b/src/Xamarin.Android.Build.Tasks/Tests/Xamarin.Android.Build.Tests/TrimmableTypeMapBuildTests.cs index 9af7a0c26b7..e7a792ce386 100644 --- a/src/Xamarin.Android.Build.Tasks/Tests/Xamarin.Android.Build.Tests/TrimmableTypeMapBuildTests.cs +++ b/src/Xamarin.Android.Build.Tasks/Tests/Xamarin.Android.Build.Tests/TrimmableTypeMapBuildTests.cs @@ -140,6 +140,18 @@ public void Build_InvalidExportField_ReportsLegacyDiagnostic ( [TestCase ("llvm-ir", AndroidRuntime.CoreCLR, "special-xml-array-return", "success")] [TestCase ("trimmable", AndroidRuntime.CoreCLR, "special-xml-array-return", "XA4263")] [TestCase ("trimmable", AndroidRuntime.NativeAOT, "special-xml-array-return", "XA4263")] + [TestCase ("llvm-ir", AndroidRuntime.CoreCLR, "export-static-constructor", "success")] + [TestCase ("trimmable", AndroidRuntime.CoreCLR, "export-static-constructor", "success")] + [TestCase ("trimmable", AndroidRuntime.NativeAOT, "export-static-constructor", "success")] + [TestCase ("llvm-ir", AndroidRuntime.CoreCLR, "export-constructor-arbitrary", "XALNS7003")] + [TestCase ("trimmable", AndroidRuntime.CoreCLR, "export-constructor-arbitrary", "XA4263")] + [TestCase ("trimmable", AndroidRuntime.NativeAOT, "export-constructor-arbitrary", "XA4263")] + [TestCase ("llvm-ir", AndroidRuntime.CoreCLR, "export-constructor-invalid-kind", "XALNS7004")] + [TestCase ("trimmable", AndroidRuntime.CoreCLR, "export-constructor-invalid-kind", "XA4263")] + [TestCase ("trimmable", AndroidRuntime.NativeAOT, "export-constructor-invalid-kind", "XA4263")] + [TestCase ("llvm-ir", AndroidRuntime.CoreCLR, "export-constructor-valid-kind", "success")] + [TestCase ("trimmable", AndroidRuntime.CoreCLR, "export-constructor-valid-kind", "success")] + [TestCase ("trimmable", AndroidRuntime.NativeAOT, "export-constructor-valid-kind", "success")] public void Build_ExportSignature_MatchesRuntimeClassification ( string typeMapImplementation, AndroidRuntime runtime, @@ -264,6 +276,48 @@ public void UnsupportedMember ( """, "unsupported", ""), + "export-static-constructor" => ( + "", + """ + [Export] + static SignaturePeer () + { + } + """, + ".cctor", + ""), + "export-constructor-arbitrary" => ( + "public sealed class ManagedOnly { }", + """ + [Export (".ctor", SuperArgumentsString = "")] + public SignaturePeer (ManagedOnly value) + { + } + """, + "SignaturePeer", + ""), + "export-constructor-invalid-kind" => ( + "public sealed class ManagedOnly { }", + """ + [Export (".ctor", SuperArgumentsString = "")] + public SignaturePeer ( + [ExportParameter (ExportParameterKind.InputStream)] ManagedOnly value) + { + } + """, + "SignaturePeer", + ""), + "export-constructor-valid-kind" => ( + "", + """ + [Export (".ctor", SuperArgumentsString = "")] + public SignaturePeer ( + [ExportParameter (ExportParameterKind.InputStream)] Stream value) + { + } + """, + "java.io.InputStream", + ""), _ => throw new InvalidOperationException ($"Unknown unsupported [Export] shape '{invalidShape}'."), }; var proj = new XamarinAndroidApplicationProject { @@ -308,8 +362,11 @@ public SignaturePeer () { Assert.IsFalse (succeeded, $"{runtime}/{typeMapImplementation} should reject {invalidShape}."); StringAssertEx.Contains ($"error {expectedCode}", builder.LastBuildOutput, $"The build should report {expectedCode}."); if (expectedCode == "XA4263") { + var expectedMemberName = invalidShape.StartsWith ("export-constructor", StringComparison.Ordinal) + ? "ExportSignatureValidation.SignaturePeer.ctor" + : "ExportSignatureValidation.SignaturePeer.UnsupportedMember"; StringAssertEx.Contains ( - "ExportSignatureValidation.SignaturePeer.UnsupportedMember", + expectedMemberName, builder.LastBuildOutput, "The diagnostic should identify the unsupported managed member." ); diff --git a/tests/Microsoft.Android.Sdk.TrimmableTypeMap.IntegrationTests/ScannerExportShapesTests.cs b/tests/Microsoft.Android.Sdk.TrimmableTypeMap.IntegrationTests/ScannerExportShapesTests.cs index 5ccddc99ad0..03bf456b296 100644 --- a/tests/Microsoft.Android.Sdk.TrimmableTypeMap.IntegrationTests/ScannerExportShapesTests.cs +++ b/tests/Microsoft.Android.Sdk.TrimmableTypeMap.IntegrationTests/ScannerExportShapesTests.cs @@ -123,6 +123,9 @@ public void Export_CrossAssemblySameManagedName_DoesNotBorrowPeerDescriptor () var peer = GetPeer ("ExportAssemblyCollisionShape", javaSourceFixturePath, UserTypesFixturePath); Assert.DoesNotContain (peer.MarshalMethods, method => method.ManagedMethodName == "UnsupportedCollision"); + Assert.DoesNotContain (peer.MarshalMethods, method => method.ManagedMethodName == "UnsupportedEnumCollision"); + Assert.DoesNotContain (peer.MarshalMethods, method => method.ManagedMethodName == "UnsupportedEnumField"); + Assert.DoesNotContain (peer.JavaFields, field => field.FieldName == "UNSUPPORTED_ENUM_FIELD"); } // === Phase A: dispatch & declaration shapes === diff --git a/tests/Microsoft.Android.Sdk.TrimmableTypeMap.IntegrationTests/UserTypesFixture/UserTypes.cs b/tests/Microsoft.Android.Sdk.TrimmableTypeMap.IntegrationTests/UserTypesFixture/UserTypes.cs index a522c81c155..70aa95a84f0 100644 --- a/tests/Microsoft.Android.Sdk.TrimmableTypeMap.IntegrationTests/UserTypesFixture/UserTypes.cs +++ b/tests/Microsoft.Android.Sdk.TrimmableTypeMap.IntegrationTests/UserTypesFixture/UserTypes.cs @@ -408,6 +408,10 @@ namespace UserApp.JavaSourceParity public class SignatureCollision { } + + public class EnumCollision + { + } } namespace UserApp @@ -417,5 +421,11 @@ public class ExportAssemblyCollisionShape : Java.Lang.Object { [Export ("unsupportedCollision")] public void UnsupportedCollision (JavaSourceParity.SignatureCollision value) { } + + [Export ("unsupportedEnumCollision")] + public JavaSourceParity.EnumCollision UnsupportedEnumCollision (JavaSourceParity.EnumCollision value) => value; + + [ExportField ("UNSUPPORTED_ENUM_FIELD")] + public JavaSourceParity.EnumCollision UnsupportedEnumField () => new (); } } diff --git a/tests/Microsoft.Android.Sdk.TrimmableTypeMap.Tests/Generator/ExportSignatureTests.cs b/tests/Microsoft.Android.Sdk.TrimmableTypeMap.Tests/Generator/ExportSignatureTests.cs index 726cb3a5dd9..aa6479ad2de 100644 --- a/tests/Microsoft.Android.Sdk.TrimmableTypeMap.Tests/Generator/ExportSignatureTests.cs +++ b/tests/Microsoft.Android.Sdk.TrimmableTypeMap.Tests/Generator/ExportSignatureTests.cs @@ -44,4 +44,67 @@ public void ScannerAndGenerator_IgnoreExportAttributeLookalikes () Assert.DoesNotContain ("NOT_AN_EXPORT", java, System.StringComparison.Ordinal); Assert.Contains ("realExport (java.lang.String", java, System.StringComparison.Ordinal); } + + [Fact] + public void Scanner_ExportConstructors_ValidateParametersAndPreserveMappings () + { + foreach (var javaName in new [] { + "my/app/ExportConstructorUnsupportedManagedParameter", + "my/app/ExportConstructorInvalidExportParameter", + }) { + var invalidPeer = FindFixtureByJavaName (javaName); + Assert.DoesNotContain (invalidPeer.MarshalMethods, method => method.IsConstructor && method.IsExport); + } + + var mappedPeer = FindFixtureByJavaName ("my/app/ExportConstructorMappedParameter"); + var mappedMethod = Assert.Single (mappedPeer.MarshalMethods, method => method.IsConstructor && method.IsExport); + Assert.Equal ("(Ljava/io/InputStream;)V", mappedMethod.JniSignature); + Assert.Equal ([ExportParameterKindInfo.InputStream], mappedMethod.ManagedParameterExportKinds); + var mappedConstructor = Assert.Single ( + mappedPeer.JavaConstructors, + constructor => constructor.JniSignature == "(Ljava/io/InputStream;)V"); + Assert.True (mappedConstructor.HasMatchingManagedCtor); + Assert.Equal ([ExportParameterKindInfo.InputStream], mappedConstructor.ManagedParameterExportKinds); + + var staticPeer = FindFixtureByJavaName ("my/app/ExportStaticConstructor"); + Assert.DoesNotContain (staticPeer.MarshalMethods, method => method.ManagedMethodName == ".cctor"); + } + + [Theory] + [InlineData ("!0")] + [InlineData ("!!0")] + [InlineData ("System.Int32&")] + [InlineData ("System.Int32*")] + [InlineData ("delegate*")] + [InlineData ("System.String[,]")] + public void ConstructorDiagnostics_OwnUnsupportedSignatureShapes (string managedTypeName) + { + Assert.True (JavaPeerScanner.IsOwnedByConstructorDiagnostics (new TypeRefData { + ManagedTypeName = managedTypeName, + AssemblyName = "Test", + })); + } + + [Fact] + public void ConstructorDiagnostics_OwnGenericInstantiationsOnly () + { + Assert.True (JavaPeerScanner.IsOwnedByConstructorDiagnostics (new TypeRefData { + ManagedTypeName = "System.Collections.Generic.List`1", + AssemblyName = "System.Collections", + GenericArguments = [ + new TypeRefData { + ManagedTypeName = "System.String", + AssemblyName = "System.Runtime", + }, + ], + })); + Assert.False (JavaPeerScanner.IsOwnedByConstructorDiagnostics (new TypeRefData { + ManagedTypeName = "MyApp.ManagedOnly", + AssemblyName = "Test", + })); + Assert.False (JavaPeerScanner.IsOwnedByConstructorDiagnostics (new TypeRefData { + ManagedTypeName = "System.String[]", + AssemblyName = "System.Runtime", + })); + } } diff --git a/tests/Microsoft.Android.Sdk.TrimmableTypeMap.Tests/Generator/TrimmableTypeMapGeneratorTests.cs b/tests/Microsoft.Android.Sdk.TrimmableTypeMap.Tests/Generator/TrimmableTypeMapGeneratorTests.cs index 2623d70e894..9b90d06e912 100644 --- a/tests/Microsoft.Android.Sdk.TrimmableTypeMap.Tests/Generator/TrimmableTypeMapGeneratorTests.cs +++ b/tests/Microsoft.Android.Sdk.TrimmableTypeMap.Tests/Generator/TrimmableTypeMapGeneratorTests.cs @@ -356,7 +356,7 @@ public void Execute_UnsupportedExportSignatures_ReportCodedDiagnosticsWithoutPar using var peReader = CreateTestFixturePEReader (); var result = CreateGenerator ().Execute ([Input ("TestFixtures", peReader)], new Version (11, 0), new HashSet ()); - Assert.Equal (8, logMessages.Count (message => message.StartsWith ("XA4263:", StringComparison.Ordinal))); + Assert.Equal (10, logMessages.Count (message => message.StartsWith ("XA4263:", StringComparison.Ordinal))); Assert.Equal (1, logMessages.Count (message => message.StartsWith ("XA4206:", StringComparison.Ordinal))); foreach (var javaName in new [] { "my/app/ExportWithUnsupportedManagedParameter", @@ -376,6 +376,14 @@ public void Execute_UnsupportedExportSignatures_ReportCodedDiagnosticsWithoutPar Assert.DoesNotContain (" unsupported (", source.Content, StringComparison.Ordinal); Assert.DoesNotContain ("UNSUPPORTED_FIELD", source.Content, StringComparison.Ordinal); } + + foreach (var javaName in new [] { + "my/app/ExportConstructorUnsupportedManagedParameter", + "my/app/ExportConstructorInvalidExportParameter", + }) { + var peer = result.AllPeers.Single (candidate => candidate.JavaName == javaName); + Assert.DoesNotContain (peer.MarshalMethods, method => method.IsConstructor && method.IsExport); + } } [Fact] diff --git a/tests/Microsoft.Android.Sdk.TrimmableTypeMap.Tests/Generator/TypeMapAssemblyGeneratorTests.cs b/tests/Microsoft.Android.Sdk.TrimmableTypeMap.Tests/Generator/TypeMapAssemblyGeneratorTests.cs index 48e55b3edc5..b4a51109e48 100644 --- a/tests/Microsoft.Android.Sdk.TrimmableTypeMap.Tests/Generator/TypeMapAssemblyGeneratorTests.cs +++ b/tests/Microsoft.Android.Sdk.TrimmableTypeMap.Tests/Generator/TypeMapAssemblyGeneratorTests.cs @@ -1386,6 +1386,36 @@ public void Generate_ExportProxy_SupportsArrayAndLegacyMarshallerHelpers () Assert.Contains ("XmlReaderResourceParser", typeNames); } + [Fact] + public void Generate_ExportConstructor_UsesParameterAdapter () + { + var peer = FindFixtureByJavaName ("my/app/ExportConstructorMappedParameter"); + + using var stream = GenerateAssembly (new [] { peer }, "ExportConstructorMapping"); + using var pe = new PEReader (stream); + var reader = pe.GetMetadataReader (); + + var adapterMethod = reader.MemberReferences + .Select (handle => (Handle: handle, Reference: reader.GetMemberReference (handle))) + .Single (member => { + if (reader.GetString (member.Reference.Name) != "FromJniHandle" || + member.Reference.Parent.Kind != HandleKind.TypeReference) { + return false; + } + var parent = reader.GetTypeReference ((TypeReferenceHandle) member.Reference.Parent); + return reader.GetString (parent.Name) == "InputStreamInvoker"; + }); + var nctorHandle = reader.MethodDefinitions.Single (handle => + reader.GetString (reader.GetMethodDefinition (handle).Name) == "nctor_0_uco"); + var nctor = reader.GetMethodDefinition (nctorHandle); + var ilBytes = pe.GetMethodBody (nctor.RelativeVirtualAddress).GetILBytes (); + Assert.NotNull (ilBytes); + if (ilBytes is null) { + throw new InvalidOperationException ("Expected exported constructor UCO IL."); + } + Assert.True (ILContainsCallToken (ilBytes, MetadataTokens.GetToken (adapterMethod.Handle))); + } + [Fact] public void Generate_ExportProxy_UsesExactCrossAssemblyTypeReferences () { diff --git a/tests/Microsoft.Android.Sdk.TrimmableTypeMap.Tests/Generator/TypeMapModelBuilderTests.cs b/tests/Microsoft.Android.Sdk.TrimmableTypeMap.Tests/Generator/TypeMapModelBuilderTests.cs index 257978bb229..817a13205b9 100644 --- a/tests/Microsoft.Android.Sdk.TrimmableTypeMap.Tests/Generator/TypeMapModelBuilderTests.cs +++ b/tests/Microsoft.Android.Sdk.TrimmableTypeMap.Tests/Generator/TypeMapModelBuilderTests.cs @@ -1564,6 +1564,21 @@ public void Fixture_ExportMarshallingShapes_PropagatesExactManagedTypeMetadata ( Assert.Equal (ExportParameterKindInfo.XmlResourceParser, resourceXmlDispatch.ReturnKind); } + [Fact] + public void Fixture_ExportConstructor_PropagatesParameterKinds () + { + var peer = FindFixtureByJavaName ("my/app/ExportConstructorMappedParameter"); + var model = BuildModel (new [] { peer }, "TypeMap"); + var proxy = Assert.Single (model.ProxyTypes); + var constructor = Assert.Single ( + proxy.UcoConstructors, + candidate => candidate.JniSignature == "(Ljava/io/InputStream;)V"); + + Assert.True (constructor.HasMatchingManagedCtor); + Assert.Equal ("System.IO.Stream", constructor.ManagedParameterTypes [0].ManagedTypeName); + Assert.Equal ([ExportParameterKindInfo.InputStream], constructor.ParameterKinds); + } + [Fact] public void Fixture_CustomView_HasTwoConstructorWrappers () { diff --git a/tests/Microsoft.Android.Sdk.TrimmableTypeMap.Tests/TestFixtures/TestTypes.cs b/tests/Microsoft.Android.Sdk.TrimmableTypeMap.Tests/TestFixtures/TestTypes.cs index 85ce4d8fbed..61f409b994f 100644 --- a/tests/Microsoft.Android.Sdk.TrimmableTypeMap.Tests/TestFixtures/TestTypes.cs +++ b/tests/Microsoft.Android.Sdk.TrimmableTypeMap.Tests/TestFixtures/TestTypes.cs @@ -667,6 +667,40 @@ public string RealExport ( => value; } + [Register ("my/app/ExportConstructorUnsupportedManagedParameter")] + public class ExportConstructorUnsupportedManagedParameter : Android.App.Activity + { + [Java.Interop.Export (".ctor", SuperArgumentsString = "")] + public ExportConstructorUnsupportedManagedParameter (UnsupportedExportValue value) { } + } + + [Register ("my/app/ExportConstructorInvalidExportParameter")] + public class ExportConstructorInvalidExportParameter : Android.App.Activity + { + [Java.Interop.Export (".ctor", SuperArgumentsString = "")] + public ExportConstructorInvalidExportParameter ( + [Java.Interop.ExportParameter (Java.Interop.ExportParameterKind.InputStream)] UnsupportedExportValue value) + { + } + } + + [Register ("my/app/ExportConstructorMappedParameter")] + public class ExportConstructorMappedParameter : Android.App.Activity + { + [Java.Interop.Export (".ctor", SuperArgumentsString = "")] + public ExportConstructorMappedParameter ( + [Java.Interop.ExportParameter (Java.Interop.ExportParameterKind.InputStream)] Stream value) + { + } + } + + [Register ("my/app/ExportStaticConstructor")] + public class ExportStaticConstructor : Java.Lang.Object + { + [Java.Interop.Export] + static ExportStaticConstructor () { } + } + /// /// Has [Export] methods with different access modifiers. /// The JCW should respect the C# visibility for [Export] methods. From 81aa51532906bba4ed3f66fbe1c39a8ca8195a0d Mon Sep 17 00:00:00 2001 From: Simon Rozsival Date: Mon, 31 Aug 2026 14:10:41 +0200 Subject: [PATCH 05/14] [typemap] Preserve exported constructor identity Ignore Export name overrides on metadata constructors, assert UCO dispatch calls the managed constructor rather than a virtual method, and recursively reserve nested structural parameter shapes for XA4260. Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com> --- .../Scanner/JavaPeerScanner.cs | 11 ++++++- .../TrimmableTypeMapBuildTests.cs | 29 ++++++++++++++++++- .../Generator/ExportSignatureTests.cs | 5 ++++ .../Generator/FixtureTestBase.cs | 5 ++++ .../TypeMapAssemblyGeneratorTests.cs | 26 +++++++++++++---- .../TestFixtures/TestTypes.cs | 4 +-- 6 files changed, 70 insertions(+), 10 deletions(-) diff --git a/src/Microsoft.Android.Sdk.TrimmableTypeMap/Scanner/JavaPeerScanner.cs b/src/Microsoft.Android.Sdk.TrimmableTypeMap/Scanner/JavaPeerScanner.cs index 88a042b043f..6df3b33ceb8 100644 --- a/src/Microsoft.Android.Sdk.TrimmableTypeMap/Scanner/JavaPeerScanner.cs +++ b/src/Microsoft.Android.Sdk.TrimmableTypeMap/Scanner/JavaPeerScanner.cs @@ -876,6 +876,11 @@ bool ValidateExportSignature (MethodDefinition methodDef, AssemblyIndex index, b internal static bool IsOwnedByConstructorDiagnostics (TypeRefData parameterType) { string managedTypeName = parameterType.ManagedTypeName; + if (managedTypeName.EndsWith ("[]", StringComparison.Ordinal)) { + return IsOwnedByConstructorDiagnostics (parameterType with { + ManagedTypeName = managedTypeName.Substring (0, managedTypeName.Length - 2), + }); + } return parameterType.GenericArguments.Count > 0 || managedTypeName.StartsWith ("!", StringComparison.Ordinal) || managedTypeName == "delegate*" || @@ -1932,6 +1937,7 @@ bool TryGetMethodRegisterInfo (MethodDefinition methodDef, AssemblyIndex index, (RegisterInfo registerInfo, ExportInfo exportInfo) ParseExportAttribute (CustomAttribute ca, MethodDefinition methodDef, AssemblyIndex index) { var value = index.DecodeAttribute (ca); + var managedName = index.Reader.GetString (methodDef.Name); // [Export("name")] or [Export] (uses method name) string? exportName = null; @@ -1974,7 +1980,10 @@ bool TryGetMethodRegisterInfo (MethodDefinition methodDef, AssemblyIndex index, } if (string.IsNullOrEmpty (exportName)) { - exportName = index.Reader.GetString (methodDef.Name); + exportName = managedName; + } + if (managedName == ".ctor") { + exportName = ".ctor"; } string resolvedExportName = exportName ?? throw new InvalidOperationException ("Export name should not be null at this point."); diff --git a/src/Xamarin.Android.Build.Tasks/Tests/Xamarin.Android.Build.Tests/TrimmableTypeMapBuildTests.cs b/src/Xamarin.Android.Build.Tasks/Tests/Xamarin.Android.Build.Tests/TrimmableTypeMapBuildTests.cs index e7a792ce386..c776b7a2176 100644 --- a/src/Xamarin.Android.Build.Tasks/Tests/Xamarin.Android.Build.Tests/TrimmableTypeMapBuildTests.cs +++ b/src/Xamarin.Android.Build.Tasks/Tests/Xamarin.Android.Build.Tests/TrimmableTypeMapBuildTests.cs @@ -152,6 +152,12 @@ public void Build_InvalidExportField_ReportsLegacyDiagnostic ( [TestCase ("llvm-ir", AndroidRuntime.CoreCLR, "export-constructor-valid-kind", "success")] [TestCase ("trimmable", AndroidRuntime.CoreCLR, "export-constructor-valid-kind", "success")] [TestCase ("trimmable", AndroidRuntime.NativeAOT, "export-constructor-valid-kind", "success")] + [TestCase ("llvm-ir", AndroidRuntime.CoreCLR, "export-named-constructor-arbitrary", "XALNS7003")] + [TestCase ("trimmable", AndroidRuntime.CoreCLR, "export-named-constructor-arbitrary", "XA4263")] + [TestCase ("trimmable", AndroidRuntime.NativeAOT, "export-named-constructor-arbitrary", "XA4263")] + [TestCase ("llvm-ir", AndroidRuntime.CoreCLR, "export-named-constructor-valid-kind", "success")] + [TestCase ("trimmable", AndroidRuntime.CoreCLR, "export-named-constructor-valid-kind", "success")] + [TestCase ("trimmable", AndroidRuntime.NativeAOT, "export-named-constructor-valid-kind", "success")] public void Build_ExportSignature_MatchesRuntimeClassification ( string typeMapImplementation, AndroidRuntime runtime, @@ -318,6 +324,27 @@ public SignaturePeer ( """, "java.io.InputStream", ""), + "export-named-constructor-arbitrary" => ( + "public sealed class ManagedOnly { }", + """ + [Export ("notAConstructor", SuperArgumentsString = "")] + public SignaturePeer (ManagedOnly value) + { + } + """, + "SignaturePeer", + ""), + "export-named-constructor-valid-kind" => ( + "", + """ + [Export ("notAConstructor", SuperArgumentsString = "")] + public SignaturePeer ( + [ExportParameter (ExportParameterKind.InputStream)] Stream value) + { + } + """, + "java.io.InputStream", + ""), _ => throw new InvalidOperationException ($"Unknown unsupported [Export] shape '{invalidShape}'."), }; var proj = new XamarinAndroidApplicationProject { @@ -362,7 +389,7 @@ public SignaturePeer () { Assert.IsFalse (succeeded, $"{runtime}/{typeMapImplementation} should reject {invalidShape}."); StringAssertEx.Contains ($"error {expectedCode}", builder.LastBuildOutput, $"The build should report {expectedCode}."); if (expectedCode == "XA4263") { - var expectedMemberName = invalidShape.StartsWith ("export-constructor", StringComparison.Ordinal) + var expectedMemberName = invalidShape.Contains ("constructor", StringComparison.Ordinal) ? "ExportSignatureValidation.SignaturePeer.ctor" : "ExportSignatureValidation.SignaturePeer.UnsupportedMember"; StringAssertEx.Contains ( diff --git a/tests/Microsoft.Android.Sdk.TrimmableTypeMap.Tests/Generator/ExportSignatureTests.cs b/tests/Microsoft.Android.Sdk.TrimmableTypeMap.Tests/Generator/ExportSignatureTests.cs index aa6479ad2de..9945dbd49e4 100644 --- a/tests/Microsoft.Android.Sdk.TrimmableTypeMap.Tests/Generator/ExportSignatureTests.cs +++ b/tests/Microsoft.Android.Sdk.TrimmableTypeMap.Tests/Generator/ExportSignatureTests.cs @@ -58,7 +58,9 @@ public void Scanner_ExportConstructors_ValidateParametersAndPreserveMappings () var mappedPeer = FindFixtureByJavaName ("my/app/ExportConstructorMappedParameter"); var mappedMethod = Assert.Single (mappedPeer.MarshalMethods, method => method.IsConstructor && method.IsExport); + Assert.Equal (".ctor", mappedMethod.JniName); Assert.Equal ("(Ljava/io/InputStream;)V", mappedMethod.JniSignature); + Assert.DoesNotContain (mappedPeer.MarshalMethods, method => method.JniName == "notAConstructor"); Assert.Equal ([ExportParameterKindInfo.InputStream], mappedMethod.ManagedParameterExportKinds); var mappedConstructor = Assert.Single ( mappedPeer.JavaConstructors, @@ -77,6 +79,9 @@ public void Scanner_ExportConstructors_ValidateParametersAndPreserveMappings () [InlineData ("System.Int32*")] [InlineData ("delegate*")] [InlineData ("System.String[,]")] + [InlineData ("System.String[,][]")] + [InlineData ("System.Int32*[]")] + [InlineData ("delegate*[]")] public void ConstructorDiagnostics_OwnUnsupportedSignatureShapes (string managedTypeName) { Assert.True (JavaPeerScanner.IsOwnedByConstructorDiagnostics (new TypeRefData { diff --git a/tests/Microsoft.Android.Sdk.TrimmableTypeMap.Tests/Generator/FixtureTestBase.cs b/tests/Microsoft.Android.Sdk.TrimmableTypeMap.Tests/Generator/FixtureTestBase.cs index 9f4c2460155..dd12967da2f 100644 --- a/tests/Microsoft.Android.Sdk.TrimmableTypeMap.Tests/Generator/FixtureTestBase.cs +++ b/tests/Microsoft.Android.Sdk.TrimmableTypeMap.Tests/Generator/FixtureTestBase.cs @@ -190,6 +190,11 @@ private protected static bool ILContainsCallToken (byte[] ilBytes, int token) return ILContainsOpcodeToken (ilBytes, token, (byte) ILOpCode.Call, (byte) ILOpCode.Callvirt); } + private protected static bool ILContainsCallvirtToken (byte[] ilBytes, int token) + { + return ILContainsOpcodeToken (ilBytes, token, (byte) ILOpCode.Callvirt); + } + private protected static bool ILContainsNewobjToken (byte[] ilBytes, int token) { return ILContainsOpcodeToken (ilBytes, token, (byte) ILOpCode.Newobj); diff --git a/tests/Microsoft.Android.Sdk.TrimmableTypeMap.Tests/Generator/TypeMapAssemblyGeneratorTests.cs b/tests/Microsoft.Android.Sdk.TrimmableTypeMap.Tests/Generator/TypeMapAssemblyGeneratorTests.cs index b4a51109e48..5a5a0c2f4f8 100644 --- a/tests/Microsoft.Android.Sdk.TrimmableTypeMap.Tests/Generator/TypeMapAssemblyGeneratorTests.cs +++ b/tests/Microsoft.Android.Sdk.TrimmableTypeMap.Tests/Generator/TypeMapAssemblyGeneratorTests.cs @@ -1405,15 +1405,29 @@ public void Generate_ExportConstructor_UsesParameterAdapter () var parent = reader.GetTypeReference ((TypeReferenceHandle) member.Reference.Parent); return reader.GetString (parent.Name) == "InputStreamInvoker"; }); - var nctorHandle = reader.MethodDefinitions.Single (handle => - reader.GetString (reader.GetMethodDefinition (handle).Name) == "nctor_0_uco"); - var nctor = reader.GetMethodDefinition (nctorHandle); - var ilBytes = pe.GetMethodBody (nctor.RelativeVirtualAddress).GetILBytes (); + var managedConstructor = reader.MemberReferences + .Select (handle => (Handle: handle, Reference: reader.GetMemberReference (handle))) + .Single (member => { + if (reader.GetString (member.Reference.Name) != ".ctor" || + member.Reference.Parent.Kind != HandleKind.TypeReference) { + return false; + } + var parent = reader.GetTypeReference ((TypeReferenceHandle) member.Reference.Parent); + return reader.GetString (parent.Name) == "ExportConstructorMappedParameter"; + }); + var ilBytes = reader.MethodDefinitions + .Select (handle => reader.GetMethodDefinition (handle)) + .Where (method => reader.GetString (method.Name).StartsWith ("nctor_", StringComparison.Ordinal)) + .Select (method => pe.GetMethodBody (method.RelativeVirtualAddress).GetILBytes ()) + .FirstOrDefault (bytes => bytes is not null && + ILContainsCallToken (bytes, MetadataTokens.GetToken (managedConstructor.Handle))); Assert.NotNull (ilBytes); - if (ilBytes is null) { + if (ilBytes is null) throw new InvalidOperationException ("Expected exported constructor UCO IL."); - } Assert.True (ILContainsCallToken (ilBytes, MetadataTokens.GetToken (adapterMethod.Handle))); + Assert.True (ILContainsCallToken (ilBytes, MetadataTokens.GetToken (managedConstructor.Handle))); + Assert.False (ILContainsCallvirtToken (ilBytes, MetadataTokens.GetToken (managedConstructor.Handle))); + Assert.False (ILContainsNewobjToken (ilBytes, MetadataTokens.GetToken (managedConstructor.Handle))); } [Fact] diff --git a/tests/Microsoft.Android.Sdk.TrimmableTypeMap.Tests/TestFixtures/TestTypes.cs b/tests/Microsoft.Android.Sdk.TrimmableTypeMap.Tests/TestFixtures/TestTypes.cs index 61f409b994f..a27e7464572 100644 --- a/tests/Microsoft.Android.Sdk.TrimmableTypeMap.Tests/TestFixtures/TestTypes.cs +++ b/tests/Microsoft.Android.Sdk.TrimmableTypeMap.Tests/TestFixtures/TestTypes.cs @@ -670,7 +670,7 @@ public string RealExport ( [Register ("my/app/ExportConstructorUnsupportedManagedParameter")] public class ExportConstructorUnsupportedManagedParameter : Android.App.Activity { - [Java.Interop.Export (".ctor", SuperArgumentsString = "")] + [Java.Interop.Export ("notAConstructor", SuperArgumentsString = "")] public ExportConstructorUnsupportedManagedParameter (UnsupportedExportValue value) { } } @@ -687,7 +687,7 @@ public ExportConstructorInvalidExportParameter ( [Register ("my/app/ExportConstructorMappedParameter")] public class ExportConstructorMappedParameter : Android.App.Activity { - [Java.Interop.Export (".ctor", SuperArgumentsString = "")] + [Java.Interop.Export ("notAConstructor", SuperArgumentsString = "")] public ExportConstructorMappedParameter ( [Java.Interop.ExportParameter (Java.Interop.ExportParameterKind.InputStream)] Stream value) { From 7a9ceb3b85be5ee689d429db7cfc436777a667fd Mon Sep 17 00:00:00 2001 From: Simon Rozsival Date: Mon, 31 Aug 2026 15:32:29 +0200 Subject: [PATCH 06/14] [typemap] Validate special mapping type identity Require Stream and XmlReader special export mappings to resolve from their framework assemblies or forwarders, preventing same-full-name user types from receiving framework adapters. Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com> --- Documentation/docs-mobile/messages/xa4263.md | 1 + .../Scanner/JavaPeerScanner.cs | 30 ++++++-- .../TrimmableTypeMapBuildTests.cs | 73 +++++++++++++++++++ ...k.TrimmableTypeMap.IntegrationTests.csproj | 3 + .../ScannerExportShapesTests.cs | 14 ++++ .../SpecialTypeCollisionFixture.csproj | 48 ++++++++++++ .../SpecialTypeCollisionTypes.cs | 39 ++++++++++ .../Scanner/JavaPeerScannerTests.Behavior.cs | 3 + 8 files changed, 204 insertions(+), 7 deletions(-) create mode 100644 tests/Microsoft.Android.Sdk.TrimmableTypeMap.IntegrationTests/SpecialTypeCollisionFixture/SpecialTypeCollisionFixture.csproj create mode 100644 tests/Microsoft.Android.Sdk.TrimmableTypeMap.IntegrationTests/SpecialTypeCollisionFixture/SpecialTypeCollisionTypes.cs diff --git a/Documentation/docs-mobile/messages/xa4263.md b/Documentation/docs-mobile/messages/xa4263.md index c672ebf7228..fa454a2957a 100644 --- a/Documentation/docs-mobile/messages/xa4263.md +++ b/Documentation/docs-mobile/messages/xa4263.md @@ -25,3 +25,4 @@ This error also occurs when `[ExportParameter]` specifies a Java mapping that is Use a primitive, string, array, Java peer, or another supported managed-to-Java type. Apply input/output stream mappings only to `Stream`, and XML parser mappings only to `XmlReader`. Do not apply these scalar mappings to arrays or other wrappers around those types. +The types must be the framework `System.IO.Stream` and `System.Xml.XmlReader` types, not user-defined types with the same full name. diff --git a/src/Microsoft.Android.Sdk.TrimmableTypeMap/Scanner/JavaPeerScanner.cs b/src/Microsoft.Android.Sdk.TrimmableTypeMap/Scanner/JavaPeerScanner.cs index 6df3b33ceb8..b4fabe79b1f 100644 --- a/src/Microsoft.Android.Sdk.TrimmableTypeMap/Scanner/JavaPeerScanner.cs +++ b/src/Microsoft.Android.Sdk.TrimmableTypeMap/Scanner/JavaPeerScanner.cs @@ -2129,7 +2129,7 @@ bool TryManagedTypeToJniDescriptor ( out string descriptor) { if (exportKind != ExportParameterKindInfo.Unspecified) { - return TryGetExportParameterDescriptor (managedType.ManagedTypeName, exportKind, out descriptor); + return TryGetExportParameterDescriptor (managedType, exportKind, out descriptor); } if (managedType.ManagedTypeName.EndsWith ("[]", StringComparison.Ordinal)) { @@ -2186,21 +2186,37 @@ bool TryManagedTypeToJniDescriptor ( return false; } - static bool TryGetExportParameterDescriptor ( - string managedTypeName, + bool TryGetExportParameterDescriptor ( + TypeRefData managedType, ExportParameterKindInfo exportKind, out string descriptor) { descriptor = exportKind switch { - ExportParameterKindInfo.InputStream when managedTypeName == "System.IO.Stream" => "Ljava/io/InputStream;", - ExportParameterKindInfo.OutputStream when managedTypeName == "System.IO.Stream" => "Ljava/io/OutputStream;", - ExportParameterKindInfo.XmlPullParser when managedTypeName == "System.Xml.XmlReader" => "Lorg/xmlpull/v1/XmlPullParser;", - ExportParameterKindInfo.XmlResourceParser when managedTypeName == "System.Xml.XmlReader" => "Landroid/content/res/XmlResourceParser;", + ExportParameterKindInfo.InputStream when IsSpecialManagedType (managedType, "System.IO.Stream", "System.Runtime", "System.Private.CoreLib") => + "Ljava/io/InputStream;", + ExportParameterKindInfo.OutputStream when IsSpecialManagedType (managedType, "System.IO.Stream", "System.Runtime", "System.Private.CoreLib") => + "Ljava/io/OutputStream;", + ExportParameterKindInfo.XmlPullParser when IsSpecialManagedType (managedType, "System.Xml.XmlReader", "System.Xml.ReaderWriter") => + "Lorg/xmlpull/v1/XmlPullParser;", + ExportParameterKindInfo.XmlResourceParser when IsSpecialManagedType (managedType, "System.Xml.XmlReader", "System.Xml.ReaderWriter") => + "Landroid/content/res/XmlResourceParser;", _ => "", }; return descriptor.Length > 0; } + bool IsSpecialManagedType (TypeRefData managedType, string managedTypeName, params string [] assemblyNames) + { + if (!string.Equals (managedType.ManagedTypeName, managedTypeName, StringComparison.Ordinal)) { + return false; + } + if (assemblyNames.Contains (managedType.AssemblyName, StringComparer.Ordinal)) { + return true; + } + return TryResolveType (managedTypeName, managedType.AssemblyName, out _, out var resolvedIndex) && + assemblyNames.Contains (resolvedIndex.MetadataAssemblyName, StringComparer.Ordinal); + } + /// /// Returns the JNI descriptor for primitive types and System.String. /// Returns null for all other types. diff --git a/src/Xamarin.Android.Build.Tasks/Tests/Xamarin.Android.Build.Tests/TrimmableTypeMapBuildTests.cs b/src/Xamarin.Android.Build.Tasks/Tests/Xamarin.Android.Build.Tests/TrimmableTypeMapBuildTests.cs index c776b7a2176..425ed52cc6c 100644 --- a/src/Xamarin.Android.Build.Tasks/Tests/Xamarin.Android.Build.Tests/TrimmableTypeMapBuildTests.cs +++ b/src/Xamarin.Android.Build.Tasks/Tests/Xamarin.Android.Build.Tests/TrimmableTypeMapBuildTests.cs @@ -401,6 +401,79 @@ public SignaturePeer () { AssertNoExportOutputs (builder, marker); } + [TestCase (AndroidRuntime.CoreCLR)] + [TestCase (AndroidRuntime.NativeAOT)] + public void Build_SpecialMappingLookalikeTypes_ReportXA4263WithoutPartialOutputs (AndroidRuntime runtime) + { + bool isRelease = runtime == AndroidRuntime.NativeAOT; + if (IgnoreUnsupportedConfiguration (runtime, release: isRelease)) { + return; + } + + var proj = new XamarinAndroidApplicationProject { + IsRelease = isRelease, + References = { + new BuildItem.Reference ("Mono.Android.Export"), + }, + }; + proj.SetRuntime (runtime); + proj.SetProperty ("AndroidTypeMapImplementation", "trimmable"); + proj.Sources.Add (new BuildItem.Source ("SpecialMappingLookalikes.cs") { + TextContent = () => """ + using Android.Runtime; + using Java.Interop; + + namespace System.IO { + public class Stream { + } + } + + namespace System.Xml { + public class XmlReader { + } + } + + namespace SpecialMappingLookalikes { + [Register ("com/example/exports/SpecialMappingLookalikePeer")] + public class SpecialMappingLookalikePeer : Java.Lang.Object { + [return: ExportParameter (ExportParameterKind.OutputStream)] + [Export ("invalidStream")] + public System.IO.Stream InvalidStream ( + [ExportParameter (ExportParameterKind.InputStream)] System.IO.Stream value) + => value; + + [return: ExportParameter (ExportParameterKind.XmlPullParser)] + [ExportField ("INVALID_XML_FIELD")] + public System.Xml.XmlReader InvalidXmlField () => new (); + + [Export ("notAConstructor", SuperArgumentsString = "")] + public SpecialMappingLookalikePeer ( + [ExportParameter (ExportParameterKind.InputStream)] System.IO.Stream value) + { + } + } + } + """, + }); + + using var builder = CreateApkBuilder (); + builder.ThrowOnBuildFailure = false; + Assert.IsFalse (builder.Build (proj), $"{runtime}/trimmable should reject special-mapping lookalike types."); + foreach (var memberName in new [] { + "SpecialMappingLookalikes.SpecialMappingLookalikePeer.InvalidStream", + "SpecialMappingLookalikes.SpecialMappingLookalikePeer.InvalidXmlField", + "SpecialMappingLookalikes.SpecialMappingLookalikePeer.ctor", + }) { + Assert.IsTrue ( + builder.LastBuildOutput.Any (line => + line.Contains ("error XA4263", StringComparison.Ordinal) && + line.Contains (memberName, StringComparison.Ordinal)), + $"The build should report XA4263 for '{memberName}'." + ); + } + AssertNoExportOutputs (builder, "invalidStream"); + } + static XamarinAndroidApplicationProject CreateExportFieldValidationProject ( AndroidRuntime runtime, string typeMapImplementation, diff --git a/tests/Microsoft.Android.Sdk.TrimmableTypeMap.IntegrationTests/Microsoft.Android.Sdk.TrimmableTypeMap.IntegrationTests.csproj b/tests/Microsoft.Android.Sdk.TrimmableTypeMap.IntegrationTests/Microsoft.Android.Sdk.TrimmableTypeMap.IntegrationTests.csproj index 96df7a6693b..7e5b7d0bd14 100644 --- a/tests/Microsoft.Android.Sdk.TrimmableTypeMap.IntegrationTests/Microsoft.Android.Sdk.TrimmableTypeMap.IntegrationTests.csproj +++ b/tests/Microsoft.Android.Sdk.TrimmableTypeMap.IntegrationTests/Microsoft.Android.Sdk.TrimmableTypeMap.IntegrationTests.csproj @@ -22,6 +22,7 @@ + @@ -36,6 +37,8 @@ ReferenceOutputAssembly=false because we don't compile against it — we just need the DLL on disk. --> + + + diff --git a/tests/Microsoft.Android.Sdk.TrimmableTypeMap.Tests/MonoAndroidFixture/ICharSequence.cs b/tests/Microsoft.Android.Sdk.TrimmableTypeMap.Tests/MonoAndroidFixture/ICharSequence.cs new file mode 100644 index 00000000000..8fbba093837 --- /dev/null +++ b/tests/Microsoft.Android.Sdk.TrimmableTypeMap.Tests/MonoAndroidFixture/ICharSequence.cs @@ -0,0 +1,7 @@ +namespace Java.Lang +{ + // Mirrors Mono.Android's interface without a [Register] attribute. + public interface ICharSequence + { + } +} diff --git a/tests/Microsoft.Android.Sdk.TrimmableTypeMap.Tests/MonoAndroidFixture/MonoAndroidFixture.csproj b/tests/Microsoft.Android.Sdk.TrimmableTypeMap.Tests/MonoAndroidFixture/MonoAndroidFixture.csproj new file mode 100644 index 00000000000..92393ba196a --- /dev/null +++ b/tests/Microsoft.Android.Sdk.TrimmableTypeMap.Tests/MonoAndroidFixture/MonoAndroidFixture.csproj @@ -0,0 +1,12 @@ + + + + $(DotNetStableTargetFramework) + latest + enable + Mono.Android + Mono.Android + false + + + diff --git a/tests/Microsoft.Android.Sdk.TrimmableTypeMap.Tests/TestFixtures/TestFixtures.csproj b/tests/Microsoft.Android.Sdk.TrimmableTypeMap.Tests/TestFixtures/TestFixtures.csproj index c5f61f8238c..fb6e87d28d5 100644 --- a/tests/Microsoft.Android.Sdk.TrimmableTypeMap.Tests/TestFixtures/TestFixtures.csproj +++ b/tests/Microsoft.Android.Sdk.TrimmableTypeMap.Tests/TestFixtures/TestFixtures.csproj @@ -11,6 +11,7 @@ + diff --git a/tests/Microsoft.Android.Sdk.TrimmableTypeMap.Tests/TestFixtures/TestTypes.cs b/tests/Microsoft.Android.Sdk.TrimmableTypeMap.Tests/TestFixtures/TestTypes.cs index a27e7464572..ac2fb69c8d4 100644 --- a/tests/Microsoft.Android.Sdk.TrimmableTypeMap.Tests/TestFixtures/TestTypes.cs +++ b/tests/Microsoft.Android.Sdk.TrimmableTypeMap.Tests/TestFixtures/TestTypes.cs @@ -29,12 +29,6 @@ public class Exception : Throwable { protected Exception (IntPtr handle, JniHandleOwnership transfer) : base (handle, transfer) { } } - - // Mirrors Mono.Android's Java.Lang.ICharSequence: an interface without a - // [Register] attribute. The trimmable typemap scanner / emitter must - // special-case it to map onto java/lang/CharSequence and dispatch via - // Android.Runtime.CharSequence.ToLocalJniHandle. - public interface ICharSequence { } } namespace Android.App From 8e3c5722823568938ff5d06f7e57b054a8757a80 Mon Sep 17 00:00:00 2001 From: Simon Rozsival Date: Thu, 3 Sep 2026 07:23:19 +0200 Subject: [PATCH 14/14] Reject invalid export parameter kinds Preserve undefined ExportParameterKind values through scanner validation so unsupported signatures report XA4263 instead of being treated as unspecified. Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com> --- .../Scanner/ExportParameterKindInfo.cs | 1 + .../Scanner/JavaPeerScanner.cs | 22 +++++++------------ .../Generator/ExportSignatureTests.cs | 1 + .../TrimmableTypeMapGeneratorTests.cs | 3 ++- .../TestFixtures/TestTypes.cs | 10 +++++++++ 5 files changed, 22 insertions(+), 15 deletions(-) diff --git a/src/Microsoft.Android.Sdk.TrimmableTypeMap/Scanner/ExportParameterKindInfo.cs b/src/Microsoft.Android.Sdk.TrimmableTypeMap/Scanner/ExportParameterKindInfo.cs index 15497a95bf7..1a102926209 100644 --- a/src/Microsoft.Android.Sdk.TrimmableTypeMap/Scanner/ExportParameterKindInfo.cs +++ b/src/Microsoft.Android.Sdk.TrimmableTypeMap/Scanner/ExportParameterKindInfo.cs @@ -6,6 +6,7 @@ namespace Microsoft.Android.Sdk.TrimmableTypeMap; /// enum ExportParameterKindInfo { + Invalid = -1, Unspecified = 0, InputStream = 1, OutputStream = 2, diff --git a/src/Microsoft.Android.Sdk.TrimmableTypeMap/Scanner/JavaPeerScanner.cs b/src/Microsoft.Android.Sdk.TrimmableTypeMap/Scanner/JavaPeerScanner.cs index 5b7dc1331fc..a401094dd30 100644 --- a/src/Microsoft.Android.Sdk.TrimmableTypeMap/Scanner/JavaPeerScanner.cs +++ b/src/Microsoft.Android.Sdk.TrimmableTypeMap/Scanner/JavaPeerScanner.cs @@ -2025,30 +2025,24 @@ static ExportParameterKindInfo GetExportParameterKind (Parameter parameter, Asse } var value = index.DecodeAttribute (ca); - if (value.FixedArguments.Length > 0 && TryConvertExportParameterKind (value.FixedArguments [0].Value, out var ctorKind)) { - return ctorKind; + if (value.FixedArguments.Length > 0) { + return ConvertExportParameterKind (value.FixedArguments [0].Value); } foreach (var named in value.NamedArguments) { - if (named.Name == "Kind" && TryConvertExportParameterKind (named.Value, out var namedKind)) { - return namedKind; + if (named.Name == "Kind") { + return ConvertExportParameterKind (named.Value); } } + + return ExportParameterKindInfo.Invalid; } return ExportParameterKindInfo.Unspecified; } - static bool TryConvertExportParameterKind (object? value, out ExportParameterKindInfo kind) - { - if (value is int i && Enum.IsDefined (typeof (ExportParameterKindInfo), i)) { - kind = (ExportParameterKindInfo) i; - return true; - } - - kind = ExportParameterKindInfo.Unspecified; - return false; - } + static ExportParameterKindInfo ConvertExportParameterKind (object? value) => + value is int i ? (ExportParameterKindInfo) i : ExportParameterKindInfo.Invalid; string BuildJniSignatureFromManaged (MethodSignature sig, IReadOnlyList parameterKinds, ExportParameterKindInfo returnKind) { diff --git a/tests/Microsoft.Android.Sdk.TrimmableTypeMap.Tests/Generator/ExportSignatureTests.cs b/tests/Microsoft.Android.Sdk.TrimmableTypeMap.Tests/Generator/ExportSignatureTests.cs index 939325bf1c5..7bc46540c58 100644 --- a/tests/Microsoft.Android.Sdk.TrimmableTypeMap.Tests/Generator/ExportSignatureTests.cs +++ b/tests/Microsoft.Android.Sdk.TrimmableTypeMap.Tests/Generator/ExportSignatureTests.cs @@ -17,6 +17,7 @@ public class ExportSignatureTests : FixtureTestBase [InlineData ("my/app/ExportWithGenericMethodParameter")] [InlineData ("my/app/ExportWithGenericInstantiation")] [InlineData ("my/app/ExportWithInvalidExportParameterType")] + [InlineData ("my/app/ExportWithInvalidExportParameterKind")] [InlineData ("my/app/ExportWithGenericExportParameter")] [InlineData ("my/app/ExportFieldWithInvalidExportParameterType")] [InlineData ("my/app/GenericExportType")] diff --git a/tests/Microsoft.Android.Sdk.TrimmableTypeMap.Tests/Generator/TrimmableTypeMapGeneratorTests.cs b/tests/Microsoft.Android.Sdk.TrimmableTypeMap.Tests/Generator/TrimmableTypeMapGeneratorTests.cs index 9b90d06e912..07d749952c6 100644 --- a/tests/Microsoft.Android.Sdk.TrimmableTypeMap.Tests/Generator/TrimmableTypeMapGeneratorTests.cs +++ b/tests/Microsoft.Android.Sdk.TrimmableTypeMap.Tests/Generator/TrimmableTypeMapGeneratorTests.cs @@ -356,7 +356,7 @@ public void Execute_UnsupportedExportSignatures_ReportCodedDiagnosticsWithoutPar using var peReader = CreateTestFixturePEReader (); var result = CreateGenerator ().Execute ([Input ("TestFixtures", peReader)], new Version (11, 0), new HashSet ()); - Assert.Equal (10, logMessages.Count (message => message.StartsWith ("XA4263:", StringComparison.Ordinal))); + Assert.Equal (11, logMessages.Count (message => message.StartsWith ("XA4263:", StringComparison.Ordinal))); Assert.Equal (1, logMessages.Count (message => message.StartsWith ("XA4206:", StringComparison.Ordinal))); foreach (var javaName in new [] { "my/app/ExportWithUnsupportedManagedParameter", @@ -365,6 +365,7 @@ public void Execute_UnsupportedExportSignatures_ReportCodedDiagnosticsWithoutPar "my/app/ExportWithGenericMethodParameter", "my/app/ExportWithGenericInstantiation", "my/app/ExportWithInvalidExportParameterType", + "my/app/ExportWithInvalidExportParameterKind", "my/app/ExportWithGenericExportParameter", "my/app/ExportFieldWithInvalidExportParameterType", "my/app/GenericExportType", diff --git a/tests/Microsoft.Android.Sdk.TrimmableTypeMap.Tests/TestFixtures/TestTypes.cs b/tests/Microsoft.Android.Sdk.TrimmableTypeMap.Tests/TestFixtures/TestTypes.cs index ac2fb69c8d4..51375b8a434 100644 --- a/tests/Microsoft.Android.Sdk.TrimmableTypeMap.Tests/TestFixtures/TestTypes.cs +++ b/tests/Microsoft.Android.Sdk.TrimmableTypeMap.Tests/TestFixtures/TestTypes.cs @@ -622,6 +622,16 @@ public UnsupportedExportValue UnsupportedMember ( => value; } + [Register ("my/app/ExportWithInvalidExportParameterKind")] + public class ExportWithInvalidExportParameterKind : Java.Lang.Object + { + [Java.Interop.Export ("unsupported")] + public void UnsupportedMember ( + [Java.Interop.ExportParameter ((Java.Interop.ExportParameterKind) 999)] int value) + { + } + } + [Register ("my/app/ExportWithGenericExportParameter")] public class ExportWithGenericExportParameter : Java.Lang.Object {