MSR: Create instances of NSObjects and INativeObjects without using reflection

Makefile

@@ -180,7 +180,7 @@ git-clean-all:
 	@git submodule foreach -q --recursive 'git clean -xffdq && git reset --hard -q'
 	@for dir in $(DEPENDENCY_DIRECTORIES); do if test -d $(CURDIR)/$$dir; then echo "Cleaning $$dir" && cd $(CURDIR)/$$dir && git clean -xffdq && git reset --hard -q && git submodule foreach -q --recursive 'git clean -xffdq'; else echo "Skipped  $$dir (does not exist)"; fi; done
 
-	@if [ -n "$(ENABLE_XAMARIN)" ] || [ -n "$(ENABLE_DOTNET)"]; then \
+	@if [ -n "$(ENABLE_XAMARIN)" ] || [ -n "$(ENABLE_DOTNET)" ]; then \
 		CONFIGURE_FLAGS=""; \
 		if [ -n "$(ENABLE_XAMARIN)" ]; then \
 			echo "Xamarin-specific build has been re-enabled"; \

src/Foundation/NSObject2.cs

@@ -69,6 +69,15 @@ public class NSObjectFlag {
 	}
 #endif
 
+#if NET
+	public interface INSObjectFactory {
+		// The method will be implemented via custom linker step if the managed static registrar is used
+		// for NSObject subclasses which have an (NativeHandle) or (IntPtr) constructor.
+		[MethodImpl(MethodImplOptions.NoInlining)]
+		virtual static NSObject ConstructNSObject (NativeHandle handle) => null;
+	}
+#endif
+
 #if NET && !COREBUILD
 	[ObjectiveCTrackedType]
 	[SupportedOSPlatform ("ios")]
@@ -81,6 +90,9 @@ public partial class NSObject : INativeObject
 #if !COREBUILD
 		, IEquatable<NSObject>
 		, IDisposable
+#endif
+#if NET
+		, INSObjectFactory
 #endif
 	{
 #if !COREBUILD

src/ObjCRuntime/IManagedRegistrar.cs

@@ -6,7 +6,6 @@
 //
 // Copyright 2023 Microsoft Corp
 
-
 #if NET
 
 #nullable enable
@@ -34,6 +33,10 @@ interface IManagedRegistrar {
 		// This method will be called once per assembly, and the implementation has to
 		// add all the interface -> wrapper type mappings to the dictionary.
 		void RegisterWrapperTypes (Dictionary<RuntimeTypeHandle, RuntimeTypeHandle> type);
+		// Create an instance of a managed NSObject subclass for an existing Objective-C object.
+		INativeObject? ConstructNSObject (RuntimeTypeHandle typeHandle, NativeHandle nativeHandle);
+		// Create an instance of a managed NSObject subclass for an existing Objective-C object.
+		INativeObject? ConstructINativeObject (RuntimeTypeHandle typeHandle, NativeHandle nativeHandle, bool owns);
 	}
 }
 

src/ObjCRuntime/INativeObject.cs

@@ -1,6 +1,7 @@
 #nullable enable
 
 using System;
+using System.Runtime.CompilerServices;
 using Foundation;
 
 #if !NET
@@ -15,6 +16,13 @@ NativeHandle Handle {
 			get;
 		}
 #endif
+
+#if NET
+		// The method will be implemented via custom linker step if the managed static registrar is used
+		// for classes which have an (NativeHandle, bool) or (IntPtr, bool) constructor.
+		[MethodImpl(MethodImplOptions.NoInlining)]
+		static virtual INativeObject? ConstructINativeObject (NativeHandle handle, bool owns) => null;
+#endif
 	}
 
 #if !COREBUILD

src/ObjCRuntime/RegistrarHelper.cs

@@ -208,6 +208,22 @@ internal static uint LookupRegisteredTypeId (Type type)
 			return entry.Registrar.LookupTypeId (type.TypeHandle);
 		}
 
+		internal static T? ConstructNSObject<T> (Type type, NativeHandle nativeHandle)
+			where T : class, INativeObject
+		{
+			if (!TryGetMapEntry (type.Assembly.GetName ().Name!, out var entry))
+				return null;
+			return (T?) entry.Registrar.ConstructNSObject (type.TypeHandle, nativeHandle);
+		}
+
+		internal static T? ConstructINativeObject<T> (Type type, NativeHandle nativeHandle, bool owns)
+			where T : class, INativeObject
+		{
+			if (!TryGetMapEntry (type.Assembly.GetName ().Name!, out var entry))
+				return null;
+			return (T?) entry.Registrar.ConstructINativeObject (type.TypeHandle, nativeHandle, owns);
+		}
+
 		// helper functions for converting between native and managed objects
 		static NativeHandle ManagedArrayToNSArray (object array, bool retain)
 		{

src/ObjCRuntime/Runtime.cs

@@ -1304,19 +1304,46 @@ static void MissingCtor (IntPtr ptr, IntPtr klass, Type type, MissingCtorResolut
 			return ConstructNSObject<T> (ptr, typeof (T), MissingCtorResolution.ThrowConstructor1NotFound);
 		}
 
-		// The generic argument T is only used to cast the return value.
 		// The 'selector' and 'method' arguments are only used in error messages.
-		static T? ConstructNSObject<T> (IntPtr ptr, Type type, MissingCtorResolution missingCtorResolution) where T : class, INativeObject
+		static T? ConstructNSObject<T> (IntPtr ptr, Type type, MissingCtorResolution missingCtorResolution) where T : NSObject
 		{
 			return ConstructNSObject<T> (ptr, type, missingCtorResolution, IntPtr.Zero, default (RuntimeMethodHandle));
 		}
 
-		// The generic argument T is only used to cast the return value.
 		// The 'selector' and 'method' arguments are only used in error messages.
-		static T? ConstructNSObject<T> (IntPtr ptr, Type type, MissingCtorResolution missingCtorResolution, IntPtr sel, RuntimeMethodHandle method_handle) where T : class, INativeObject
+		static T? ConstructNSObject<T> (IntPtr ptr, Type type, MissingCtorResolution missingCtorResolution, IntPtr sel, RuntimeMethodHandle method_handle)
+			where T : NSObject
+#if NET
+				, INSObjectFactory
+#endif
 		{
 			if (type is null)
 				throw new ArgumentNullException (nameof (type));
+#if NET
+			if (Runtime.IsManagedStaticRegistrar) {
+				T? instance = default;
+				var nativeHandle = new NativeHandle (ptr);
+
+				if (typeof (T) != typeof (NSObject)
+					&& (typeof (T) == type || typeof (T).IsGenericType)
+					&& !(typeof (T).IsInterface || typeof (T).IsAbstract)) {
+					instance = ConstructNSObjectViaFactoryMethod (nativeHandle);
+				}
+
+				// If we couldn't create an instance of T through the factory method, we'll use the lookup table.
+				// This table can't instantiate generic types though.
+				if (!type.IsGenericType) {
+					instance ??= RegistrarHelper.ConstructNSObject<T> (type, nativeHandle);
+				}
+
+				if (instance is null) {
+					MissingCtor (ptr, IntPtr.Zero, type, missingCtorResolution, sel, method_handle);
+					return null;
+				}
+
+				return instance;
+			}
+#endif
 
 			var ctor = GetIntPtrConstructor (type);
 
@@ -1337,6 +1364,22 @@ static void MissingCtor (IntPtr ptr, IntPtr klass, Type type, MissingCtorResolut
 #endif
 
 			return (T) ctor.Invoke (ctorArguments);
+
+#if NET
+			static T? ConstructNSObjectViaFactoryMethod (NativeHandle handle)
+			{
+				NSObject? obj = T.ConstructNSObject (handle);
+				if (obj is T instance) {
+					return instance;
+				}
+
+				// if the factory method returns a NSObject subclass but we don't expect that specific type,
+				// we need to dispose it and return null anyway
+				obj?.Dispose ();
+
+				return null;
+			}
+#endif
 		}
 
 		// The generic argument T is only used to cast the return value.
@@ -1348,6 +1391,50 @@ static void MissingCtor (IntPtr ptr, IntPtr klass, Type type, MissingCtorResolut
 			if (type.IsByRef)
 				type = type.GetElementType ()!;
 
+#if NET
+			if (Runtime.IsManagedStaticRegistrar) {
+				var nativeHandle = new NativeHandle (ptr);
+				T? instance = null;
+
+				// - The factory method on T is only useful if we know the exact generic type (it's not INativeObject)
+				//   and we're not just falling back to the INativeObject/NSObject factory method (which would throw
+				//   an exception anyway).
+				// - If `T` is different from `type`, we'd rather use the lookup table to create the instance of the 
+				//   more specialized `type` than "just" T unless it's a generic type. We can't create instances of generic
+				//   types through the lookup table.
+				// - It doesn't make sense to create an instance of an interface or an abstract class.
+				if (typeof (T) != typeof (INativeObject)
+					&& typeof (T) != typeof (NSObject)
+					&& (typeof (T) == type || typeof (T).IsGenericType)
+					&& !(typeof (T).IsInterface || typeof (T).IsAbstract))
+				{
+					instance = ConstructINativeObjectViaFactoryMethod (nativeHandle, owns);
+				}
+
+				// if the factory didn't work and the type isn't generic, we can try the lookup table
+				if (instance is null && !type.IsGenericType) {
+					// if type is an NSObject, we prefer the NSObject lookup table
+					if (type != typeof (NSObject) && type.IsSubclassOf (typeof (NSObject))) {
+						instance = (T?)(INativeObject?) RegistrarHelper.ConstructNSObject<T> (type, nativeHandle);
+						if (instance is not null && owns) {
+							Runtime.TryReleaseINativeObject (instance);
+						}
+					}
+
+					if (instance is null && type != typeof (INativeObject)) {
+						instance = RegistrarHelper.ConstructINativeObject<T> (type, nativeHandle, owns);
+					}
+				}
+
+				if (instance is null) {
+					MissingCtor (ptr, IntPtr.Zero, type, missingCtorResolution, sel, method_handle);
+					return null;
+				}
+
+				return instance;
+			}
+#endif
+
 			var ctor = GetIntPtr_BoolConstructor (type);
 
 			if (ctor is null) {
@@ -1368,6 +1455,25 @@ static void MissingCtor (IntPtr ptr, IntPtr klass, Type type, MissingCtorResolut
 			ctorArguments [1] = owns;
 
 			return (T?) ctor.Invoke (ctorArguments);
+
+#if NET
+			// This is a workaround for a compiler issue.
+			static T? ConstructINativeObjectViaFactoryMethod (NativeHandle nativeHandle, bool owns)
+			{
+				INativeObject? obj = T.ConstructINativeObject (nativeHandle, owns);
+				if (obj is T instance) {
+					return instance;
+				}
+
+				// if the factory method returns an INativeObject but we don't expect that specific type,
+				// we need to release it and return null anyway
+				if (obj is not null) {
+					Runtime.TryReleaseINativeObject(obj);
+				}
+
+				return null;
+			}
+#endif
 		}
 
 		static IntPtr CreateNSObject (IntPtr type_gchandle, IntPtr handle, NSObject.Flags flags)
@@ -1747,7 +1853,7 @@ static Type LookupINativeObjectImplementation (IntPtr ptr, Type target_type, Typ
 					// native objects and NSObject instances.
 					throw ErrorHelper.CreateError (8004, $"Cannot create an instance of {implementation.FullName} for the native object 0x{ptr:x} (of type '{Class.class_getName (Class.GetClassForObject (ptr))}'), because another instance already exists for this native object (of type {o.GetType ().FullName}).");
 				}
-				return ConstructNSObject<INativeObject> (ptr, implementation, MissingCtorResolution.ThrowConstructor1NotFound, sel, method_handle);
+				return (INativeObject?) ConstructNSObject<NSObject> (ptr, implementation!, MissingCtorResolution.ThrowConstructor1NotFound, sel, method_handle);
 			}
 
 			return ConstructINativeObject<INativeObject> (ptr, owns, implementation, MissingCtorResolution.ThrowConstructor2NotFound, sel, method_handle);
@@ -1804,10 +1910,6 @@ static Type LookupINativeObjectImplementation (IntPtr ptr, Type target_type, Typ
 					// native objects and NSObject instances.
 					throw ErrorHelper.CreateError (8004, $"Cannot create an instance of {implementation.FullName} for the native object 0x{ptr:x} (of type '{Class.class_getName (Class.GetClassForObject (ptr))}'), because another instance already exists for this native object (of type {o.GetType ().FullName}).");
 				}
-				var rv = (T?) ConstructNSObject<T> (ptr, implementation, MissingCtorResolution.ThrowConstructor1NotFound);
-				if (owns)
-					TryReleaseINativeObject (rv);
-				return rv;
 			}
 
 			return ConstructINativeObject<T> (ptr, owns, implementation, MissingCtorResolution.ThrowConstructor2NotFound, sel, method_handle);

tools/common/StaticRegistrar.cs

@@ -839,6 +839,9 @@ protected override bool ContainsPlatformReference (AssemblyDefinition assembly)
 		}
 
 		protected override IEnumerable<TypeReference> CollectTypes (AssemblyDefinition assembly)
+			=> GetAllTypes (assembly);
+
+		internal static IEnumerable<TypeReference> GetAllTypes (AssemblyDefinition assembly)
 		{
 			var queue = new Queue<TypeDefinition> ();
 

tools/dotnet-linker/AppBundleRewriter.cs

@@ -339,6 +339,12 @@ public TypeReference ObjCRuntime_IManagedRegistrar {
 			}
 		}
 
+		public TypeReference Foundation_INSObjectFactory {
+			get {
+				return GetTypeReference (PlatformAssembly, "Foundation.INSObjectFactory", out var _);
+			}
+		}
+
 		public TypeReference ObjCRuntime_INativeObject {
 			get {
 				return GetTypeReference (PlatformAssembly, "ObjCRuntime.INativeObject", out var _);
@@ -716,6 +722,49 @@ public MethodReference IManagedRegistrar_LookupTypeId {
 			}
 		}
 
+		public MethodReference IManagedRegistrar_ConstructNSObject {
+			get {
+				return GetMethodReference (PlatformAssembly,
+						ObjCRuntime_IManagedRegistrar, "ConstructNSObject",
+						isStatic: false,
+						System_RuntimeTypeHandle,
+						ObjCRuntime_NativeHandle);
+			}
+		}
+
+		public MethodReference INSObjectFactory_ConstructNSObject {
+			get {
+				return GetMethodReference (PlatformAssembly,
+						Foundation_INSObjectFactory, "ConstructNSObject",
+						nameof (INSObjectFactory_ConstructNSObject),
+						isStatic: true,
+						ObjCRuntime_NativeHandle);
+			}
+		}
+
+		public MethodReference IManagedRegistrar_ConstructINativeObject {
+			get {
+				return GetMethodReference (PlatformAssembly,
+						ObjCRuntime_IManagedRegistrar, "ConstructINativeObject",
+						nameof (IManagedRegistrar_ConstructINativeObject),
+						isStatic: false,
+						System_RuntimeTypeHandle,
+						ObjCRuntime_NativeHandle,
+						System_Boolean);
+			}
+		}
+
+		public MethodReference INativeObject_ConstructINativeObject {
+			get {
+				return GetMethodReference (PlatformAssembly,
+						ObjCRuntime_INativeObject, "ConstructINativeObject",
+						nameof (INativeObject_ConstructINativeObject),
+						isStatic: true,
+						ObjCRuntime_NativeHandle,
+						System_Boolean);
+			}
+		}
+
 		public MethodReference IManagedRegistrar_RegisterWrapperTypes {
 			get {
 				return GetMethodReference (PlatformAssembly, ObjCRuntime_IManagedRegistrar, "RegisterWrapperTypes", (v) =>
@@ -1058,6 +1107,15 @@ public MethodReference Runtime_RetainAndAutoreleaseNativeObject {
 			}
 		}
 
+		public MethodReference Runtime_TryReleaseINativeObject {
+			get {
+				return GetMethodReference (PlatformAssembly,
+						ObjCRuntime_Runtime, "TryReleaseINativeObject",
+						isStatic: true,
+						ObjCRuntime_INativeObject);
+			}
+		}
+
 		public MethodReference UnmanagedCallersOnlyAttribute_Constructor {
 			get {
 				return GetMethodReference (CorlibAssembly, "System.Runtime.InteropServices.UnmanagedCallersOnlyAttribute", ".ctor", (v) => v.IsDefaultConstructor ());