[RGen] Emit the methods for protocol wrappers. (#23463)

We need to add the following changes:

- Add helper methods to convert a protocol method to a wrapper method,
mainly remove not needed modifiers.
- Add export attributes just for wrapper methods context is a protocol
and method is not a extension.
- EmitMethod will use the send directly when we are generating a wrapper
method.
- Add missing protocol member attrs for methods.

---------

Co-authored-by: Copilot <[email protected]>
Co-authored-by: GitHub Actions Autoformatter <[email protected]>

Author: 3 people

src/rgen/Microsoft.Macios.Generator/DataModel/Method.Generator.cs

@@ -257,4 +257,21 @@ public Method ToProtocolMethod (TypeInfo protocol)
 			],
 		};
 	}
+
+	/// <summary>
+	/// Converts the current method into a method suitable for a protocol wrapper class.
+	/// This involves removing modifiers like 'unsafe', 'partial', and 'virtual'.
+	/// </summary>
+	/// <returns>A new <see cref="Method"/> instance with updated modifiers for the protocol wrapper.</returns>
+	public Method ToProtocolWrapperMethod ()
+	{
+		// contains the exact same data but the modifiers are updated to remove virtual and partial if they are present
+		return this with {
+			Modifiers = [
+				.. Modifiers.Where (m =>
+					!m.IsKind (SyntaxKind.PartialKeyword) &&
+					!m.IsKind (SyntaxKind.VirtualKeyword)),
+			]
+		};
+	}
 }

src/rgen/Microsoft.Macios.Generator/Emitters/ClassEmitterExtensions.cs

@@ -82,10 +82,11 @@ void EmitField (string selector, string selectorName)
 	/// <summary>
 	/// Emits the body for a method that does not return a value.
 	/// </summary>
+	/// <param name="context">Current binding context.</param>
 	/// <param name="method">The method for which to generate the body.</param>
 	/// <param name="invocations">The method invocations and argument transformations.</param>
 	/// <param name="methodBlock">The writer for the method block.</param>
-	static void EmitVoidMethodBody (in Method method, in MethodInvocations invocations, TabbedWriter<StringWriter> methodBlock)
+	static void EmitVoidMethodBody (in BindingContext context, in Method method, in MethodInvocations invocations, TabbedWriter<StringWriter> methodBlock)
 	{
 		// validate and init the needed temp variables
 		foreach (var argument in invocations.Arguments) {
@@ -98,7 +99,8 @@ static void EmitVoidMethodBody (in Method method, in MethodInvocations invocatio
 			methodBlock.Write (argument.PreCallConversion, verifyTrivia: false);
 		}
 
-		if (method.IsExtension) {
+		// if we are dealing with a protocol or an extension method, we need to call send directly
+		if (context.Changes.BindingType == BindingType.Protocol || method.IsExtension) {
 			methodBlock.WriteRaw (
 $@"{ExpressionStatement (invocations.Send)}
 {ExpressionStatement (KeepAlive (method.This))}
@@ -127,7 +129,7 @@ static void EmitVoidMethodBody (in Method method, in MethodInvocations invocatio
 	/// <param name="method">The method for which to generate the body.</param>
 	/// <param name="invocations">The method invocations and argument transformations.</param>
 	/// <param name="methodBlock">The writer for the method block.</param>
-	static void EmitReturnMethodBody (in Method method, in MethodInvocations invocations, TabbedWriter<StringWriter> methodBlock)
+	static void EmitReturnMethodBody (in BindingContext context, in Method method, in MethodInvocations invocations, TabbedWriter<StringWriter> methodBlock)
 	{
 		// similar to the void method but we need to create a temp variable to store the return value
 		// and do any conversions that might be needed for the return value, for example byte to bool
@@ -144,7 +146,8 @@ static void EmitReturnMethodBody (in Method method, in MethodInvocations invocat
 			methodBlock.Write (argument.PreCallConversion, verifyTrivia: false);
 		}
 
-		if (method.IsExtension) {
+		// if we are dealing with a protocol or an extension method, we need to call send directly
+		if (context.Changes.BindingType == BindingType.Protocol || method.IsExtension) {
 			methodBlock.WriteRaw (
 $@"{tempDeclaration}
 {ExpressionStatement (invocations.Send)}
@@ -191,6 +194,12 @@ public static void EmitMethod (this IClassEmitter self, in BindingContext contex
 		classBlock.AppendMemberAvailability (method.SymbolAvailability);
 		classBlock.AppendGeneratedCodeAttribute (optimizable: true);
 
+		// append the export attribute to the method just in case it is a protocol method in a wrapper class,
+		// that is when the method is not an extension method and the binding type is protocol.
+		if (context.Changes.BindingType == BindingType.Protocol && !method.IsExtension) {
+			classBlock.AppendExportAttribute (method.ExportMethodData);
+		}
+
 		using (var methodBlock = classBlock.CreateBlock (method.ToDeclaration ().ToString (), block: true)) {
 			// write any possible thread check at the beginning of the method
 			if (uiThreadCheck is not null) {
@@ -203,9 +212,9 @@ public static void EmitMethod (this IClassEmitter self, in BindingContext contex
 			var invocations = GetInvocations (method);
 
 			if (method.ReturnType.IsVoid) {
-				EmitVoidMethodBody (method, invocations, methodBlock);
+				EmitVoidMethodBody (context, method, invocations, methodBlock);
 			} else {
-				EmitReturnMethodBody (method, invocations, methodBlock);
+				EmitReturnMethodBody (context, method, invocations, methodBlock);
 			}
 		}
 

src/rgen/Microsoft.Macios.Generator/Emitters/ProtocolEmitter.cs

@@ -192,6 +192,12 @@ public bool TryEmit (in BindingContext bindingContext, [NotNullWhen (false)] out
 				builder.AppendProtocolMemberData (protocolMember);
 			}
 
+			// append the methods to the protocol member data 
+			foreach (var method in bindingContext.Changes.Methods.OrderBy (m => m.Name)) {
+				var protocolMember = new ProtocolMemberData (method);
+				builder.AppendProtocolMemberData (protocolMember);
+			}
+
 			var modifiers = $"{string.Join (' ', bindingContext.Changes.Modifiers)} ";
 			// class declaration, the analyzer should ensure that the class is static, otherwise it will fail to compile with an error.
 			using (var interfaceBlock = builder.CreateBlock (

src/rgen/Microsoft.Macios.Generator/Emitters/ProtocolWrapperEmitter.cs

@@ -18,7 +18,7 @@ namespace Microsoft.Macios.Generator.Emitters;
 /// <summary>
 /// Emits the wrapper class for a protocol.
 /// </summary>
-class ProtocolWrapperEmitter : ICodeEmitter {
+class ProtocolWrapperEmitter : IClassEmitter {
 	/// <inheritdoc />
 	public string GetSymbolName (in Binding binding) => Nomenclator.GetProtocolWrapperName (binding.Name);
 
@@ -32,8 +32,8 @@ class ProtocolWrapperEmitter : ICodeEmitter {
 	/// <param name="classBlock">The writer for the class block.</param>
 	void EmitDefaultConstructors (in BindingContext bindingContext, TabbedWriter<StringWriter> classBlock)
 	{
-		classBlock.WriteLine ("// Implement default constructor");
 		classBlock.WriteLine ();
+		classBlock.WriteLine ("// Implement default constructor");
 	}
 
 	/// <summary>
@@ -48,8 +48,8 @@ void EmitProperties (in BindingContext context, TabbedWriter<StringWriter> class
 			.OrderBy (p => p.Name);
 
 		foreach (var property in allProperties) {
-			classBlock.WriteLine ($"// Implement property: {property.Name}");
 			classBlock.WriteLine ();
+			classBlock.WriteLine ($"// Implement property: {property.Name}");
 		}
 	}
 
@@ -65,7 +65,7 @@ void EmitMethods (in BindingContext context, TabbedWriter<StringWriter> classBlo
 			.OrderBy (m => m.Name);
 
 		foreach (var method in allMethods) {
-			classBlock.WriteLine ($"// Implement method: {method.Name}");
+			this.EmitMethod (context, method.ToProtocolWrapperMethod (), classBlock);
 			classBlock.WriteLine ();
 		}
 	}

src/rgen/Microsoft.Macios.Generator/IO/TabbedStringBuilderExtensions.cs

@@ -19,7 +19,8 @@ static class TabbedStringBuilderExtensions {
 	/// <param name="self">A tabbed string builder.</param>
 	/// <param name="optimizable">If the binding is Optimizable or not.</param>
 	/// <returns>The current builder.</returns>
-	public static TabbedWriter<StringWriter> AppendGeneratedCodeAttribute (this TabbedWriter<StringWriter> self, bool optimizable = true)
+	public static TabbedWriter<StringWriter> AppendGeneratedCodeAttribute (this TabbedWriter<StringWriter> self,
+		bool optimizable = true)
 	{
 		if (optimizable) {
 			const string attr = "[BindingImpl (BindingImplOptions.GeneratedCode | BindingImplOptions.Optimizable)]";
@@ -39,7 +40,8 @@ public static TabbedWriter<StringWriter> AppendGeneratedCodeAttribute (this Tabb
 	/// <param name="className">The class that contains the notification.</param>
 	/// <param name="notification">The name of the notification.</param>
 	/// <returns></returns>
-	public static TabbedWriter<StringWriter> AppendNotificationAdvice (this TabbedWriter<StringWriter> self, in string className, in string notification)
+	public static TabbedWriter<StringWriter> AppendNotificationAdvice (this TabbedWriter<StringWriter> self,
+		in string className, in string notification)
 	{
 		string attr =
 			$"[Advice (\"Use '{className}.Notifications.{notification}' helper method instead.\")]";
@@ -52,7 +54,8 @@ public static TabbedWriter<StringWriter> AppendNotificationAdvice (this TabbedWr
 	/// </summary>
 	/// <param name="self">A tabbed string builder.</param>
 	/// <returns>The current builder.</returns>
-	public static TabbedWriter<StringWriter> AppendEditorBrowsableAttribute (this TabbedWriter<StringWriter> self, EditorBrowsableState state)
+	public static TabbedWriter<StringWriter> AppendEditorBrowsableAttribute (this TabbedWriter<StringWriter> self,
+		EditorBrowsableState state)
 	{
 		string attr = $"[EditorBrowsable (EditorBrowsableState.{state})]";
 		self.WriteLine (attr);
@@ -206,13 +209,15 @@ public static TabbedWriter<StringWriter> AppendProtocolMemberData (this TabbedWr
 
 		// the following are optional since we might not have a proxy for a callback but are used in both cases (methods and properties)
 		if (protocolMemberData.ReturnTypeDelegateProxy is not null) {
-			sb.Append ($", ReturnTypeDelegateProxy = typeof ({protocolMemberData.ReturnTypeDelegateProxy.Value.GetIdentifierSyntax ()})");
+			sb.Append (
+				$", ReturnTypeDelegateProxy = typeof ({protocolMemberData.ReturnTypeDelegateProxy.Value.GetIdentifierSyntax ()})");
 		}
 
 		if (protocolMemberData.ParameterBlockProxy.Length > 0) {
 			// build the parameter block proxy string array
 			var blockProxies = string.Join (", ",
-				protocolMemberData.ParameterBlockProxy.Select (x => x is null ? "null" : $"typeof ({x.Value.GetIdentifierSyntax ()})"));
+				protocolMemberData.ParameterBlockProxy.Select (x =>
+					x is null ? "null" : $"typeof ({x.Value.GetIdentifierSyntax ()})"));
 			sb.Append ($", ParameterBlockProxy = new Type? [] {{ {blockProxies} }}");
 		}
 
@@ -252,4 +257,19 @@ public static TabbedWriter<StringWriter> AppendRequiredMemberAttribute (this Tab
 		self.WriteLine ($"[{RequiredMember}]");
 		return self;
 	}
+
+	/// <summary>
+	/// Appends an `[Export<Method>]` attribute to the current writer.
+	/// This is a simplified version that only includes the selector, as required by the registrar.
+	/// </summary>
+	/// <param name="self">A tabbed string writer.</param>
+	/// <param name="exportData">The export data for the method, from which the selector is extracted.</param>
+	/// <returns>The current writer.</returns>
+	public static TabbedWriter<StringWriter> AppendExportAttribute (this TabbedWriter<StringWriter> self,
+		ExportData<ObjCBindings.Method> exportData)
+	{
+		// the resitrar does not care about other flags but the selector, so we can just use the selector
+		self.WriteLine ($"[Export<Method> (\"{exportData.Selector}\")]");
+		return self;
+	}
 }

tests/rgen/Microsoft.Macios.Generator.Tests/DataModel/InterfaceCodeChangesTests.cs

@@ -1251,7 +1251,7 @@ void CodeChangesFromInterfaceDeclaration (ApplePlatform platform, string inputTe
 		var node = sourceTrees [0].GetRoot ()
 			.DescendantNodes ()
 			.OfType<InterfaceDeclarationSyntax> ()
-			.LastOrDefault (); // always get the last one so that inheritance tests are correct
+			.LastOrDefault (); // always get the last one so that inherirance tests are correct
 		Assert.NotNull (node);
 		var semanticModel = compilation.GetSemanticModel (sourceTrees [0]);
 		var changes = Binding.FromDeclaration (node, semanticModel);

tests/rgen/Microsoft.Macios.Generator.Tests/DataModel/MethodTests/FromDeclarationTests.cs

@@ -5,6 +5,7 @@
 using System.Collections;
 using System.Collections.Generic;
 using System.Linq;
+using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.Macios.Generator.Attributes;
@@ -1113,4 +1114,43 @@ interface IAVAudioMixing {
 		Assert.True (protocolMethod.IsExtension);
 	}
 
+	[Theory]
+	[AllSupportedPlatforms]
+	void ToProtocolWrapperMethodTests (ApplePlatform platform)
+	{
+		var inputText = @"
+using AVFoundation;
+using Foundation;
+using ObjCBindings;
+using ObjCRuntime;
+using System.Runtime.Versioning;
+
+namespace Microsoft.Macios.Generator.Tests.Protocols.Data;
+
+[SupportedOSPlatform (""ios"")]
+[SupportedOSPlatform (""tvos"")]
+[SupportedOSPlatform (""macos"")]
+[SupportedOSPlatform (""maccatalyst13.1"")]
+[BindingType<Protocol>]
+interface IAVAudioMixing {
+
+	[Export<Method> (""destinationForMixer:bus:"")]
+	public virtual unsafe partial AVAudioMixingDestination? DestinationForMixer (AVAudioNode mixer, nuint bus);
+}
+";
+
+		var (compilation, syntaxTrees) = CreateCompilation (platform, sources: inputText);
+		Assert.Single (syntaxTrees);
+		var semanticModel = compilation.GetSemanticModel (syntaxTrees [0]);
+		var declaration = syntaxTrees [0].GetRoot ()
+			.DescendantNodes ().OfType<MethodDeclarationSyntax> ()
+			.FirstOrDefault ();
+		Assert.NotNull (declaration);
+		Assert.True (Method.TryCreate (declaration, semanticModel, out var changes));
+		Assert.NotNull (changes);
+		var protocolWrapperMethod = changes.Value.ToProtocolWrapperMethod ();
+		Assert.DoesNotContain (protocolWrapperMethod.Modifiers, m => m.IsKind (SyntaxKind.VirtualKeyword));
+		Assert.DoesNotContain (protocolWrapperMethod.Modifiers, m => m.IsKind (SyntaxKind.PartialKeyword));
+		Assert.Contains (protocolWrapperMethod.Modifiers, m => m.IsKind (SyntaxKind.PublicKeyword));
+	}
 }

tests/rgen/Microsoft.Macios.Generator.Tests/IO/TabbedStringBuilderTests.cs

@@ -878,6 +878,32 @@ void AppendDynamicDependencyAttributeWithMethodTests (Method method, string expe
 		Assert.Equal (expectedString, result);
 	}
 
+	public static IEnumerable<object []> AppendExportAttributeTestData {
+		get {
+			// Simple selector
+			yield return [new ExportData<ObjCBindings.Method> ("mySelector:"), "[Export<Method> (\"mySelector:\")]\n"];
+
+			// Selector with multiple parts
+			yield return [new ExportData<ObjCBindings.Method> ("mySelector:withObject:"), "[Export<Method> (\"mySelector:withObject:\")]\n"];
+
+			// Selector with no parameters
+			yield return [new ExportData<ObjCBindings.Method> ("mySelector"), "[Export<Method> (\"mySelector\")]\n"];
+
+			// Null selector
+			yield return [new ExportData<ObjCBindings.Method> (null), "[Export<Method> (\"\")]\n"];
+		}
+	}
+
+	[Theory]
+	[MemberData (nameof (AppendExportAttributeTestData))]
+	void AppendExportAttributeTests (ExportData<ObjCBindings.Method> exportData, string expectedString)
+	{
+		var block = new TabbedStringBuilder (sb);
+		block.AppendExportAttribute (exportData);
+		var result = block.ToCode ();
+		Assert.Equal (expectedString, result);
+	}
+
 	[Fact]
 	public void ClearTests ()
 	{

tests/rgen/Microsoft.Macios.Generator.Tests/Protocols/Data/ExpectedIAVAudio3DMixing.cs

@@ -349,6 +349,7 @@ internal static void _SetSourceMode (this IAVAudio3DMixing self, global::AVFound
 
 internal unsafe sealed class AVAudio3DMixingWrapper : BaseWrapper, IAVAudio3DMixing
 {
+
 	// Implement default constructor
 
 	// Implement property: Obstruction
@@ -364,5 +365,4 @@ internal unsafe sealed class AVAudio3DMixingWrapper : BaseWrapper, IAVAudio3DMix
 	// Implement property: ReverbBlend
 
 	// Implement property: SourceMode
-
 }

tests/rgen/Microsoft.Macios.Generator.Tests/Protocols/Data/ExpectedIAVAudioMixing.cs

@@ -16,6 +16,7 @@ namespace Microsoft.Macios.Generator.Tests.Protocols.Data;
 [SupportedOSPlatform ("maccatalyst13.1")]
 [Protocol (Name = "AVAudioMixing", WrapperType = typeof (AVAudioMixingWrapper))]
 [ProtocolMember (IsRequired = true, IsProperty = true, IsStatic = false, Name = "Volume", Selector = "volume", PropertyType = typeof (float), GetterSelector = "volume", SetterSelector = "setVolume:", ArgumentSemantic = ArgumentSemantic.None)]
+[ProtocolMember (IsRequired = true, IsProperty = false, IsStatic = false, Name = "DestinationForMixer", Selector = "destinationForMixer:bus:", ReturnType = typeof (global::AVFoundation.AVAudioMixingDestination), ParameterType = new Type [] { typeof (global::AVFoundation.AVAudioNode), typeof (global::System.UIntPtr) }, ParameterByRef = new bool [] { false, false }, ParameterBlockProxy = new Type? [] { null, null })]
 public partial interface IAVAudioMixing : INativeObject, IDisposable
 {
 
@@ -100,6 +101,7 @@ public virtual partial float Volume
 
 internal unsafe sealed class AVAudioMixingWrapper : BaseWrapper, IAVAudioMixing
 {
+
 	// Implement default constructor
 
 	// Implement property: Obstruction
@@ -118,6 +120,20 @@ internal unsafe sealed class AVAudioMixingWrapper : BaseWrapper, IAVAudioMixing
 
 	// Implement property: Volume
 
-	// Implement method: DestinationForMixer
+	[SupportedOSPlatform ("macos")]
+	[SupportedOSPlatform ("ios")]
+	[SupportedOSPlatform ("tvos")]
+	[SupportedOSPlatform ("maccatalyst13.1")]
+	[BindingImpl (BindingImplOptions.GeneratedCode | BindingImplOptions.Optimizable)]
+	[Export<Method> ("destinationForMixer:bus:")]
+	public global::AVFoundation.AVAudioMixingDestination? DestinationForMixer (global::AVFoundation.AVAudioNode mixer, global::System.UIntPtr bus)
+	{
+		var mixer__handle__ = mixer!.GetNonNullHandle (nameof (mixer));
+		global::AVFoundation.AVAudioMixingDestination? ret;
+		ret = global::ObjCRuntime.Runtime.GetNSObject<global::AVFoundation.AVAudioMixingDestination> (global::ObjCRuntime.Messaging.NativeHandle_objc_msgSend_NativeHandle_UIntPtr (this.Handle, global::ObjCRuntime.Selector.GetHandle ("destinationForMixer:bus:"), mixer__handle__, bus));
+		global::System.GC.KeepAlive (this);
+		global::System.GC.KeepAlive (mixer);
+		return ret;
+	}
 
 }