diff --git a/Documentation/guides/internals/JavaJNI_Interop.md b/Documentation/guides/internals/JavaJNI_Interop.md index e316b6e5219..5ebc3ae7c75 100644 --- a/Documentation/guides/internals/JavaJNI_Interop.md +++ b/Documentation/guides/internals/JavaJNI_Interop.md @@ -230,6 +230,8 @@ A Java-side constructor and a managed-side constructor do not allocate one share On the managed side, [`TrimmableTypeMap`](../../../src/Mono.Android/Microsoft.Android.Runtime/TrimmableTypeMap.cs) uses generated mapping attributes to resolve a Java class and target type. Its [`JavaPeerProxy`](../../../src/Mono.Android/Java.Interop/JavaPeerProxy.cs) can create the managed object from a handle without late-bound `Activator.CreateInstance`; activation also accounts for an existing replaceable peer. [`TrimmableTypeMapTypeManager`](../../../src/Mono.Android/Microsoft.Android.Runtime/TrimmableTypeMapTypeManager.cs) resolves names/types, while [`TrimmableTypeMapValueManager`](../../../src/Mono.Android/Microsoft.Android.Runtime/TrimmableTypeMapValueManager.cs) checks for registered peers and handles construction/ownership. +Proxies for sealed managed types defined in `Mono.Android` pass `isSealed: true` to the `JavaPeerProxy` constructor. The resulting `JavaPeerProxy.IsSealed` property lets target-type lookups use `FindClass` and `IsInstanceOf` without inspecting `Type.Assembly` at runtime. Other peers pass `isSealed: false` and still use the object's actual Java class hierarchy, even for sealed app and library types: these classes can use a different class loader, so resolving their class by name could incorrectly reject a valid object. + Every generated JCW implements the Java [`IGCUserPeer`](../../../src/java-runtime/java/mono/android/IGCUserPeer.java) hooks `monodroidAddReference` and `monodroidClearReferences`. Managed [`JavaMarshalRegisteredPeers`](../../../src/Mono.Android/Microsoft.Android.Runtime/JavaMarshalRegisteredPeers.cs) tracks add/peek/remove/finalize operations, and the GC bridge coordinates the two collectors. Local and global JNI references have different lifetimes: a managed wrapper may need a global reference to keep its peer accessible after a JNI call returns. `JniHandleOwnership` records whether an incoming reference is transferred. Calling `Dispose()` can remove the association; a raw `IntPtr` retained afterward is not a safe substitute for a live managed peer. For invalid reference diagnostics, see [Debugging JNI Object Reference Crashes](debug-jni-objrefs.md). ## Diagnosing a broken interop path diff --git a/src/Microsoft.Android.Build.Tasks/Tests/Microsoft.Android.Build.Tasks.Tests/GenerateTrimmableTypeMapTests.cs b/src/Microsoft.Android.Build.Tasks/Tests/Microsoft.Android.Build.Tasks.Tests/GenerateTrimmableTypeMapTests.cs index 715cfd75fb4..fcfcda05027 100644 --- a/src/Microsoft.Android.Build.Tasks/Tests/Microsoft.Android.Build.Tasks.Tests/GenerateTrimmableTypeMapTests.cs +++ b/src/Microsoft.Android.Build.Tasks/Tests/Microsoft.Android.Build.Tasks.Tests/GenerateTrimmableTypeMapTests.cs @@ -2,6 +2,9 @@ using System.Collections.Generic; using System.IO; using System.Linq; +using System.Reflection; +using System.Reflection.Metadata.Ecma335; +using System.Reflection.PortableExecutable; using System.Xml.Linq; using Microsoft.Android.Sdk.TrimmableTypeMap; using Microsoft.Android.Tasks; @@ -14,6 +17,79 @@ namespace Xamarin.Android.Build.Tests { [Parallelizable (ParallelScope.Children)] public class GenerateTrimmableTypeMapTests : BaseTest { + [Test] + public void SealedFrameworkProxiesPassIsSealedToBase ( + [Values ("Mono.Android", "Other")] string assemblyName, + [Values] bool isSealed, + [Values] bool alias, + [Values] bool generic) + { + var peer = new JavaPeerInfo { + JavaName = "example/Peer", + CompatJniName = "example/Peer", + ManagedTypeName = generic ? "Example.Peer`1" : "Example.Peer", + ManagedTypeNamespace = "Example", + ManagedTypeShortName = generic ? "Peer`1" : "Peer", + AssemblyName = assemblyName, + IsFrameworkAssembly = true, + IsSealed = isSealed, + IsGenericDefinition = generic, + DoNotGenerateAcw = true, + ActivationCtor = new ActivationCtorInfo { + DeclaringTypeName = generic ? "Example.Peer`1" : "Example.Peer", + DeclaringAssemblyName = assemblyName, + DeclaringType = new TypeRefData { + ManagedTypeName = generic ? "Example.Peer`1" : "Example.Peer", + AssemblyName = assemblyName, + }, + Style = ActivationCtorStyle.XamarinAndroid, + }, + JavaConstructors = [new JavaConstructorInfo { JniSignature = "()V", ConstructorIndex = 0 }], + }; + var peers = new List { peer }; + if (alias) { + peers.Add (peer with { + ManagedTypeName = "Example.OtherPeer", + ManagedTypeShortName = "OtherPeer", + IsSealed = false, + IsGenericDefinition = false, + ActivationCtor = new ActivationCtorInfo { + DeclaringTypeName = "Example.OtherPeer", + DeclaringAssemblyName = assemblyName, + DeclaringType = new TypeRefData { + ManagedTypeName = "Example.OtherPeer", + AssemblyName = assemblyName, + }, + Style = ActivationCtorStyle.XamarinAndroid, + }, + }); + } + + var generator = new TypeMapAssemblyGenerator (new Version (12, 0)); + var model = generator.CreateModel (peers, "_Example.TypeMap"); + using var stream = new MemoryStream (); + generator.Generate (model, stream, useSharedTypemapUniverse: true); + stream.Position = 0; + using var assembly = Mono.Cecil.AssemblyDefinition.ReadAssembly (stream); + Assert.AreEqual (alias ? 2 : 1, model.ProxyTypes.Count, "Every peer must emit a proxy."); + foreach (var proxy in model.ProxyTypes) { + bool eligible = assemblyName == "Mono.Android" && isSealed && proxy.TargetType.ManagedTypeName == peer.ManagedTypeName; + const string expectedBase = "Java.Interop.JavaPeerProxy"; + var type = assembly.MainModule.Types.Single (type => type.Name == proxy.TypeName); + Assert.AreEqual (expectedBase, type.BaseType.FullName, type.FullName); + var constructor = type.Methods.Single (method => method.IsConstructor); + var baseCall = constructor.Body.Instructions + .Single (instruction => instruction.Operand is Mono.Cecil.MethodReference { Name: ".ctor" }); + var baseConstructor = (Mono.Cecil.MethodReference) baseCall.Operand; + Assert.AreEqual (expectedBase, baseConstructor.DeclaringType.FullName, "The constructor must call the selected base."); + Assert.AreEqual (3, baseConstructor.Parameters.Count, "The constructor must pass IsSealed to the base."); + Assert.AreEqual ("System.Boolean", baseConstructor.Parameters [2].ParameterType.FullName); + var expectedIsSealed = eligible ? Mono.Cecil.Cil.Code.Ldc_I4_1 : Mono.Cecil.Cil.Code.Ldc_I4_0; + Assert.AreEqual (expectedIsSealed, baseCall.Previous.OpCode.Code, type.FullName); + Assert.IsFalse (type.Properties.Any (property => property.Name == "IsSealed"), "Proxies must not override IsSealed."); + } + } + [Test] public void AssemblyQualifiedApplicationTypeReferencesSelectCorrectPeer () { @@ -380,6 +456,57 @@ public void LoadCustomViewTypeNames_InvalidEntryThrows () StringAssert.Contains ("Invalid custom view map entry 'invalid'", exception?.Message); } + [Test] + public void ScannerRecordsIsSealedFromTypeMetadata () + { + var pe = new PEAssemblyBuilder (new Version (11, 0, 0, 0)); + pe.EmitPreamble ("ScannerPeers", "ScannerPeers.dll"); + var registerAttribute = pe.Metadata.AddTypeReference ( + pe.MonoAndroidRef, + pe.Metadata.GetOrAddString ("Android.Runtime"), + pe.Metadata.GetOrAddString ("RegisterAttribute")); + var registerCtor = pe.AddMemberRef (registerAttribute, ".ctor", + sig => sig.MethodSignature (isInstanceMethod: true).Parameters (1, + rt => rt.Void (), + p => p.AddParameter ().Type ().String ())); + var objectType = pe.Metadata.AddTypeReference ( + pe.SystemRuntimeRef, + pe.Metadata.GetOrAddString ("System"), + pe.Metadata.GetOrAddString ("Object")); + var nonsealedType = pe.Metadata.AddTypeDefinition ( + TypeAttributes.Public | TypeAttributes.Class, + pe.Metadata.GetOrAddString ("Example"), + pe.Metadata.GetOrAddString ("NonsealedPeer"), + objectType, + MetadataTokens.FieldDefinitionHandle (1), + MetadataTokens.MethodDefinitionHandle (1)); + var sealedType = pe.Metadata.AddTypeDefinition ( + TypeAttributes.Public | TypeAttributes.Class | TypeAttributes.Sealed, + pe.Metadata.GetOrAddString ("Example"), + pe.Metadata.GetOrAddString ("SealedPeer"), + nonsealedType, + MetadataTokens.FieldDefinitionHandle (1), + MetadataTokens.MethodDefinitionHandle (1)); + foreach (var (type, javaName) in new [] { + (nonsealedType, "example/NonsealedPeer"), + (sealedType, "example/SealedPeer"), + }) { + pe.Metadata.AddCustomAttribute (type, registerCtor, pe.BuildAttributeBlob (blob => blob.WriteSerializedString (javaName))); + } + + using var stream = new MemoryStream (); + pe.WritePE (stream); + stream.Position = 0; + using var reader = new PEReader (stream); + using var scanner = new JavaPeerScanner (); + var peers = scanner.Scan ([new AssemblyInput ("ScannerPeers", "", reader)]); + + var sealedPeer = peers.Single (peer => peer.JavaName == "example/SealedPeer"); + var nonsealedPeer = peers.Single (peer => peer.JavaName == "example/NonsealedPeer"); + Assert.IsTrue (sealedPeer.IsSealed, sealedPeer.ManagedTypeName); + Assert.IsFalse (nonsealedPeer.IsSealed, nonsealedPeer.ManagedTypeName); + } + [Test] public void Execute_WithMonoAndroid_ProducesOutputs () { diff --git a/src/Microsoft.Android.Build.Tasks/Tests/Microsoft.Android.Build.Tasks.Tests/TrimmableTypeMapIncrementalTests.cs b/src/Microsoft.Android.Build.Tasks/Tests/Microsoft.Android.Build.Tasks.Tests/TrimmableTypeMapIncrementalTests.cs index 257c4e77c08..c5bee806c0e 100644 --- a/src/Microsoft.Android.Build.Tasks/Tests/Microsoft.Android.Build.Tasks.Tests/TrimmableTypeMapIncrementalTests.cs +++ b/src/Microsoft.Android.Build.Tasks/Tests/Microsoft.Android.Build.Tasks.Tests/TrimmableTypeMapIncrementalTests.cs @@ -11,6 +11,29 @@ namespace Xamarin.Android.Build.Tests; [TestFixture] public class TrimmableTypeMapIncrementalTests { + [TestCase (false)] + [TestCase (true)] + public void ChangingFrameworkSealednessRegeneratesTypeMap (bool isSealed) + { + var peer = CreatePeer ("Mono.Android", "Java.Lang.String", "java/lang/String") with { + IsSealed = isSealed, + }; + var changedPeer = peer with { IsSealed = !isSealed }; + + CollectionAssert.AreEqual ( + new [] { "_Mono.Android.TypeMap" }, + GetChangedAssemblyNames ([peer], [changedPeer])); + + var version = new Version (12, 0); + var generator = new TypeMapAssemblyGenerator (version); + var initial = generator.CreateModel ([peer], "_Mono.Android.TypeMap"); + var changed = generator.CreateModel ([changedPeer], "_Mono.Android.TypeMap"); + CollectionAssert.AreNotEqual ( + MetadataHelper.ComputeFingerprints (initial, version, useSharedTypemapUniverse: true, includeIncremental: false).Content, + MetadataHelper.ComputeFingerprints (changed, version, useSharedTypemapUniverse: true, includeIncremental: false).Content, + "Changing the emitted base class must also change the deterministic MVID."); + } + [Test] public void ChangedCrossAssemblyAliasRegeneratesOwner () { diff --git a/src/Microsoft.Android.Sdk.TrimmableTypeMap/Generator/MetadataHelper.cs b/src/Microsoft.Android.Sdk.TrimmableTypeMap/Generator/MetadataHelper.cs index cb4e5ec2517..d106decbc70 100644 --- a/src/Microsoft.Android.Sdk.TrimmableTypeMap/Generator/MetadataHelper.cs +++ b/src/Microsoft.Android.Sdk.TrimmableTypeMap/Generator/MetadataHelper.cs @@ -97,6 +97,7 @@ public static ModelFingerprints ComputeFingerprints ( writer.WriteString (incremental, proxy.Namespace); } WriteTypeRef (writer, both, proxy.TargetType); + writer.WriteBoolean (both, proxy.CanResolveFromSealedTargetType); if (includeIncremental) { WriteOptionalTypeRef (writer, incremental, proxy.InvokerType); } diff --git a/src/Microsoft.Android.Sdk.TrimmableTypeMap/Generator/Model/TypeMapAssemblyData.cs b/src/Microsoft.Android.Sdk.TrimmableTypeMap/Generator/Model/TypeMapAssemblyData.cs index 928c7216800..5e28474d5f6 100644 --- a/src/Microsoft.Android.Sdk.TrimmableTypeMap/Generator/Model/TypeMapAssemblyData.cs +++ b/src/Microsoft.Android.Sdk.TrimmableTypeMap/Generator/Model/TypeMapAssemblyData.cs @@ -109,6 +109,11 @@ sealed class JavaPeerProxyData /// public required TypeRefData TargetType { get; init; } + /// + /// True when the sealed Mono.Android target can use the runtime's class loader. + /// + public bool CanResolveFromSealedTargetType { get; init; } + /// /// Reference to the invoker type (for interfaces/abstract types). Null if not applicable. /// diff --git a/src/Microsoft.Android.Sdk.TrimmableTypeMap/Generator/ModelBuilder.cs b/src/Microsoft.Android.Sdk.TrimmableTypeMap/Generator/ModelBuilder.cs index faa0742bdb1..c91ea07719c 100644 --- a/src/Microsoft.Android.Sdk.TrimmableTypeMap/Generator/ModelBuilder.cs +++ b/src/Microsoft.Android.Sdk.TrimmableTypeMap/Generator/ModelBuilder.cs @@ -305,6 +305,7 @@ static JavaPeerProxyData BuildProxyType (JavaPeerInfo peer, string jniName, Hash }, IsAcw = isAcw, IsGenericDefinition = peer.IsGenericDefinition, + CanResolveFromSealedTargetType = peer.IsSealed && string.Equals (peer.AssemblyName, "Mono.Android", StringComparison.Ordinal), CannotRegisterInStaticConstructor = peer.CannotRegisterInStaticConstructor, }; diff --git a/src/Microsoft.Android.Sdk.TrimmableTypeMap/Generator/TypeMapAssemblyEmitter.cs b/src/Microsoft.Android.Sdk.TrimmableTypeMap/Generator/TypeMapAssemblyEmitter.cs index 95aa672b85e..f7fbcb340eb 100644 --- a/src/Microsoft.Android.Sdk.TrimmableTypeMap/Generator/TypeMapAssemblyEmitter.cs +++ b/src/Microsoft.Android.Sdk.TrimmableTypeMap/Generator/TypeMapAssemblyEmitter.cs @@ -669,20 +669,20 @@ void EmitProxyType (JavaPeerProxyData proxy, Dictionary sig.MethodSignature (isInstanceMethod: true).Parameters (2, + sig => sig.MethodSignature (isInstanceMethod: true).Parameters (3, rt => rt.Void (), p => { p.AddParameter ().Type ().String (); p.AddParameter ().Type ().Type (_systemTypeRef, false); + p.AddParameter ().Type ().Boolean (); })); var typeDefHandle = metadata.AddTypeDefinition ( TypeAttributes.Public | TypeAttributes.Sealed | TypeAttributes.Class, metadata.GetOrAddString (proxy.Namespace), metadata.GetOrAddString (proxy.TypeName), - proxyBaseType, + _javaPeerProxyRef, MetadataTokens.FieldDefinitionHandle (metadata.GetRowCount (TableIndex.Field) + 1), MetadataTokens.MethodDefinitionHandle (metadata.GetRowCount (TableIndex.MethodDef) + 1)); @@ -699,7 +699,8 @@ void EmitProxyType (JavaPeerProxyData proxy, Dictionary /// If true, this is a Managed Callable Wrapper (MCW) binding type. diff --git a/src/Microsoft.Android.Sdk.TrimmableTypeMap/Scanner/JavaPeerScanner.cs b/src/Microsoft.Android.Sdk.TrimmableTypeMap/Scanner/JavaPeerScanner.cs index d9947ece9d1..8cbdf285d89 100644 --- a/src/Microsoft.Android.Sdk.TrimmableTypeMap/Scanner/JavaPeerScanner.cs +++ b/src/Microsoft.Android.Sdk.TrimmableTypeMap/Scanner/JavaPeerScanner.cs @@ -428,6 +428,7 @@ void ScanAssembly (AssemblyIndex index, Dictionary<(string ManagedName, string A var isGenericDefinition = typeDef.GetGenericParameters ().Count > 0; var isInterface = (typeDef.Attributes & TypeAttributes.Interface) != 0; var isAbstract = (typeDef.Attributes & TypeAttributes.Abstract) != 0; + var isSealed = (typeDef.Attributes & TypeAttributes.Sealed) != 0; var isFrameworkAssembly = frameworkAssemblyNames.Contains (index.AssemblyName); var isUnconditional = !isFrameworkAssembly && @@ -483,6 +484,7 @@ void ScanAssembly (AssemblyIndex index, Dictionary<(string ManagedName, string A Annotations = annotationParser.Parse (typeDef.GetCustomAttributes (), index), IsInterface = isInterface, IsAbstract = isAbstract, + IsSealed = isSealed, DoNotGenerateAcw = doNotGenerateAcw, IsFromJniTypeSignature = registerInfo?.IsFromJniTypeSignature ?? false, IsUnconditional = isUnconditional, diff --git a/src/Mono.Android/Java.Interop/JavaPeerProxy.cs b/src/Mono.Android/Java.Interop/JavaPeerProxy.cs index f6d966df235..e22d3fc73f1 100644 --- a/src/Mono.Android/Java.Interop/JavaPeerProxy.cs +++ b/src/Mono.Android/Java.Interop/JavaPeerProxy.cs @@ -42,12 +42,18 @@ public sealed class JavaPeerAliasesAttribute : Attribute public abstract class JavaPeerProxy : Attribute { protected JavaPeerProxy (string jniName, Type targetType) + : this (jniName, targetType, false) + { + } + + protected JavaPeerProxy (string jniName, Type targetType, bool isSealed) { ArgumentNullException.ThrowIfNull (jniName); ArgumentNullException.ThrowIfNull (targetType); JniName = jniName; TargetType = targetType; + IsSealed = isSealed; } /// @@ -69,6 +75,15 @@ protected JavaPeerProxy (string jniName, Type targetType) /// public Type TargetType { get; } + /// + /// Gets whether the sealed target can be resolved directly using the runtime's class loader. + /// + /// + /// Generated proxies pass only for sealed Mono.Android targets. External + /// targets pass even when sealed, because they can use a different class loader. + /// + public bool IsSealed { get; } + /// /// Returns when the UCO constructor callback should skip /// activation because a managed peer already exists for the given JNI handle diff --git a/src/Mono.Android/Microsoft.Android.Runtime/TrimmableTypeMap.cs b/src/Mono.Android/Microsoft.Android.Runtime/TrimmableTypeMap.cs index e7f95ac9c10..8fbf1b26937 100644 --- a/src/Mono.Android/Microsoft.Android.Runtime/TrimmableTypeMap.cs +++ b/src/Mono.Android/Microsoft.Android.Runtime/TrimmableTypeMap.cs @@ -298,14 +298,10 @@ bool TryResolveProxyFromSealedTargetType ( { proxy = null; // App peers can use class loaders which differ from the runtime fallback loader. + // The generator marks only sealed Mono.Android targets as safe for this lookup. if (targetType is null || !targetType.IsSealed || - targetType.Assembly != typeof (Java.Lang.Object).Assembly) { - return false; - } - - var targetProxy = GetProxyForManagedType (targetType); - if (targetProxy is null) { + GetProxyForManagedType (targetType) is not { IsSealed: true } targetProxy) { return false; } diff --git a/src/Mono.Android/PublicAPI/API-37/PublicAPI.Unshipped.txt b/src/Mono.Android/PublicAPI/API-37/PublicAPI.Unshipped.txt index 915343ff9e8..7ab639ea5c4 100644 --- a/src/Mono.Android/PublicAPI/API-37/PublicAPI.Unshipped.txt +++ b/src/Mono.Android/PublicAPI/API-37/PublicAPI.Unshipped.txt @@ -8356,7 +8356,9 @@ Java.Interop.JavaPeerCallbackFormatAttribute Java.Interop.JavaPeerCallbackFormatAttribute.JavaPeerCallbackFormatAttribute(int version) -> void Java.Interop.JavaPeerCallbackFormatAttribute.Version.get -> int Java.Interop.JavaPeerProxy +Java.Interop.JavaPeerProxy.IsSealed.get -> bool Java.Interop.JavaPeerProxy.JavaPeerProxy(string! jniName, System.Type! targetType) -> void +Java.Interop.JavaPeerProxy.JavaPeerProxy(string! jniName, System.Type! targetType, bool isSealed) -> void Java.Interop.JavaPeerProxy.JniName.get -> string! Java.Interop.JavaPeerProxy.TargetType.get -> System.Type! Java.Interop.JniMarshalTyped diff --git a/tests/Mono.Android-Tests/Mono.Android-Tests/Java.Interop/TrimmableTypeMapTypeManagerTests.cs b/tests/Mono.Android-Tests/Mono.Android-Tests/Java.Interop/TrimmableTypeMapTypeManagerTests.cs index bc5548346b1..cadbf00e55f 100644 --- a/tests/Mono.Android-Tests/Mono.Android-Tests/Java.Interop/TrimmableTypeMapTypeManagerTests.cs +++ b/tests/Mono.Android-Tests/Mono.Android-Tests/Java.Interop/TrimmableTypeMapTypeManagerTests.cs @@ -7,6 +7,7 @@ using System.Threading; using System.Threading.Tasks; using Android.Runtime; +using Dalvik.SystemInterop; using Java.Interop; using Microsoft.Android.Runtime; using NUnit.Framework; @@ -231,6 +232,7 @@ public void TryGetJniNameForManagedType_DifferentClosedGenerics_UseGenericDefini } [Test] + [Category ("NativeAOTTrimmable")] public void GetProxyForJavaObject_SealedTarget_ReturnsProxy () { using var value = new Java.Lang.String ("value"); @@ -241,9 +243,11 @@ public void GetProxyForJavaObject_SealedTarget_ReturnsProxy () return; } Assert.AreEqual (typeof (Java.Lang.String), proxy.TargetType); + Assert.IsTrue (proxy.IsSealed); } [Test] + [Category ("NativeAOTTrimmable")] public void GetProxyForJavaObject_IncompatibleSealedTarget_ReturnsNull () { #pragma warning disable CA1422 // Integer(int) constructor is obsolete since API 33. @@ -255,6 +259,63 @@ public void GetProxyForJavaObject_IncompatibleSealedTarget_ReturnsNull () } [Test] + [Category ("NativeAOTTrimmable")] + public void GetProxyForJavaObject_NonSealedTarget_UsesObjectHierarchy () + { + using var value = new Java.Lang.String ("value"); + var proxy = TrimmableTypeMap.Instance.GetProxyForJavaObject (value.Handle, typeof (Java.Lang.Object)); + + Assert.AreEqual (typeof (Java.Lang.String), proxy?.TargetType); + } + + [Test] + public void GetProxyForJavaObject_NonSealedTarget_DoesNotCacheManagedTarget () + { + using var value = new Java.Lang.String ("value"); + var instance = TrimmableTypeMap.Instance; + var cache = GetProxyCache (instance); + var targetType = typeof (Java.Lang.Object); + cache.TryRemove (targetType, out var previous); + try { + var proxy = instance.GetProxyForJavaObject (value.Handle, targetType); + + Assert.AreEqual (typeof (Java.Lang.String), proxy?.TargetType); + Assert.IsFalse (cache.ContainsKey (targetType), "A nonsealed target should not trigger a managed-proxy lookup."); + } finally { + if (previous is not null) + cache.TryAdd (targetType, previous); + } + } + + [Test] + [Category ("NativeAOTTrimmable")] + public void GetProxyForJavaObject_SealedExternalTarget_DoesNotUseSealedShortcut () + { + const string javaClassName = "net.dot.android.test.TrimmableRuntimeJavaInteropPeer"; + var sourceDir = Android.App.Application.Context.ApplicationInfo?.SourceDir + ?? throw new InvalidOperationException ("The application APK path is unavailable."); + using var loader = new PathClassLoader (sourceDir, null); + using var javaClass = loader.LoadClass (javaClassName) + ?? throw new InvalidOperationException ($"Could not load {javaClassName} from a separate class loader."); + using var constructor = javaClass.GetConstructor () + ?? throw new InvalidOperationException ($"{javaClassName} has no default constructor."); + using var instance = constructor.NewInstance (); + using var runtimeClass = Java.Lang.Class.ForName ( + javaClassName, + initialize: false, + Android.App.Application.Context.ClassLoader); + + Assert.IsFalse (runtimeClass.IsInstance (instance), + "The test instance must not belong to the runtime's application class loader."); + + var proxy = TrimmableTypeMap.Instance.GetProxyForJavaObject (instance.Handle, typeof (TrimmableRuntimeJavaInteropPeer)); + + Assert.AreEqual (typeof (TrimmableRuntimeJavaInteropPeer), proxy?.TargetType); + Assert.IsFalse (proxy?.IsSealed); + } + + [Test] + [Category ("NativeAOTTrimmable")] public void CreateInstance_SealedClosedGenericTarget_ReturnsClosedPeer () { using var value = new Java.Util.ArrayList ();