[RGen] Add support for nested classes to all emitter. (#23401)

While we added the support of nested class for strong dicts there is no
reason not to support it on other binding types.

---------

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

Author: mandel-macaque

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

@@ -56,25 +56,28 @@ public bool TryEmit (in BindingContext bindingContext, [NotNullWhen (false)] out
 		var registrationName = bindingData.CategoryType.Value.Name;
 
 		// namespace declaration
-		bindingContext.Builder.WriteLine ();
-		bindingContext.Builder.WriteLine ($"namespace {string.Join (".", bindingContext.Changes.Namespace)};");
-		bindingContext.Builder.WriteLine ();
+		this.EmitNamespace (bindingContext);
 
-		// append the class availability, this will add the necessary attributes to the class
-		bindingContext.Builder.AppendMemberAvailability (bindingContext.Changes.SymbolAvailability);
+		using (var _ = this.EmitOuterClasses (bindingContext, out var builder)) {
+			// append the class availability, this will add the necessary attributes to the class
+			builder.AppendMemberAvailability (bindingContext.Changes.SymbolAvailability);
 
-		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 classBlock = bindingContext.Builder.CreateBlock ($"{(string.IsNullOrWhiteSpace (modifiers) ? string.Empty : modifiers)}class {bindingContext.Changes.Name}", true)) {
-			// emit the fields for the selectors before we register the class or anything
-			this.EmitSelectorFields (bindingContext, classBlock);
+			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 classBlock = builder.CreateBlock (
+					   $"{(string.IsNullOrWhiteSpace (modifiers) ? string.Empty : modifiers)}class {bindingContext.Changes.Name}",
+					   true)) {
+				// emit the fields for the selectors before we register the class or anything
+				this.EmitSelectorFields (bindingContext, classBlock);
 
-			classBlock.WriteLine ($"static readonly {NativeHandle} {ClassPtr} = {BindingSyntaxFactory.Class}.GetHandle (\"{registrationName}\");");
+				classBlock.WriteLine (
+					$"static readonly {NativeHandle} {ClassPtr} = {BindingSyntaxFactory.Class}.GetHandle (\"{registrationName}\");");
 
-			// categories only have methods since we cannot have extensions properties in C#.
-			this.EmitMethods (bindingContext, classBlock);
-		}
+				// categories only have methods since we cannot have extensions properties in C#.
+				this.EmitMethods (bindingContext, classBlock);
+			}
 
-		return true;
+			return true;
+		}
 	}
 }

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

@@ -400,72 +400,57 @@ public bool TryEmit (in BindingContext bindingContext, [NotNullWhen (false)] out
 		}
 
 		// namespace declaration
-		bindingContext.Builder.WriteLine ();
-		bindingContext.Builder.WriteLine ($"namespace {string.Join (".", bindingContext.Changes.Namespace)};");
-		bindingContext.Builder.WriteLine ();
-
-		// if the type of the change contains outer classes, we need to emit the outer classes first
-		TabbedWriter<StringWriter> builder = bindingContext.Builder;
-		// create a list for the outer classes builders so that we can dispose them later, we are using a linked list
-		// because AddFirst is O(1) and we need to dispose them in the reverse order of creation
-		var outerClassesBuilders = new LinkedList<TabbedWriter<StringWriter>> ();
-		if (bindingContext.Changes.OuterClasses.Length > 0) {
-			// emit the outer classes and set the builder to the innermost class
-			foreach (var outerClass in bindingContext.Changes.OuterClasses) {
-				var outerModifiers = $"{string.Join (' ', outerClass.Modifiers)} ";
-				builder = builder.CreateBlock ($"{(string.IsNullOrWhiteSpace (outerModifiers) ? string.Empty : outerModifiers)}class {outerClass.Name}", true);
-				// add the current builder to the list so that we can dispose it later, we add it to the head of the
-				// list so that we can dispose it in the reverse order of creation
-				outerClassesBuilders.AddFirst (builder);
-			}
-		}
+		this.EmitNamespace (bindingContext);
 
-		// register the class only if we are not dealing with a static class
-		var bindingData = (BindingTypeData<Class>) bindingContext.Changes.BindingInfo;
-		// Registration depends on the class name. If the binding data contains a name, we use that one, else
-		// we use the name of the class
-		var registrationName = bindingData.Name ?? bindingContext.Changes.Name;
+		using (var _ = this.EmitOuterClasses (bindingContext, out var builder)) {
 
-		// append the class availability, this will add the necessary attributes to the class
-		bindingContext.Builder.AppendMemberAvailability (bindingContext.Changes.SymbolAvailability);
-		if (!bindingContext.Changes.IsStatic) {
-			builder.WriteLine ($"[Register (\"{registrationName}\", true)]");
-		}
-		var modifiers = $"{string.Join (' ', bindingContext.Changes.Modifiers)} ";
-		using (var classBlock = builder.CreateBlock ($"{(string.IsNullOrWhiteSpace (modifiers) ? string.Empty : modifiers)}class {bindingContext.Changes.Name}", true)) {
-			// emit the fields for the selectors before we register the class or anything
-			this.EmitSelectorFields (bindingContext, classBlock);
+			// register the class only if we are not dealing with a static class
+			var bindingData = (BindingTypeData<Class>) bindingContext.Changes.BindingInfo;
+			// Registration depends on the class name. If the binding data contains a name, we use that one, else
+			// we use the name of the class
+			var registrationName = bindingData.Name ?? bindingContext.Changes.Name;
 
+			// append the class availability, this will add the necessary attributes to the class
+			bindingContext.Builder.AppendMemberAvailability (bindingContext.Changes.SymbolAvailability);
 			if (!bindingContext.Changes.IsStatic) {
-				classBlock.AppendGeneratedCodeAttribute (optimizable: true);
-				classBlock.WriteLine ($"static readonly {NativeHandle} {ClassPtr} = {BindingSyntaxFactory.Class}.GetHandle (\"{registrationName}\");");
-				classBlock.WriteLine ();
-				classBlock.WriteDocumentation (Documentation.Class.ClassHandle (bindingContext.Changes.Name));
-				classBlock.WriteLine ($"public override {NativeHandle} ClassHandle => {ClassPtr};");
-				classBlock.WriteLine ();
-
-				EmitDefaultConstructors (bindingContext: bindingContext,
-					classBlock: classBlock,
-					disableDefaultCtor: bindingData.Flags.HasFlag (ObjCBindings.Class.DisableDefaultCtor));
-
-				// emit any other constructor that is not the default one
-				EmitConstructors (bindingContext, classBlock);
+				builder.WriteLine ($"[Register (\"{registrationName}\", true)]");
 			}
 
-			EmitFields (bindingContext.Changes.Name, bindingContext.Changes.Properties, classBlock,
-				out var notificationProperties);
-			EmitProperties (bindingContext, classBlock);
-			this.EmitMethods (bindingContext, classBlock);
+			var modifiers = $"{string.Join (' ', bindingContext.Changes.Modifiers)} ";
+			using (var classBlock =
+				   builder.CreateBlock (
+					   $"{(string.IsNullOrWhiteSpace (modifiers) ? string.Empty : modifiers)}class {bindingContext.Changes.Name}",
+					   true)) {
+				// emit the fields for the selectors before we register the class or anything
+				this.EmitSelectorFields (bindingContext, classBlock);
+
+				if (!bindingContext.Changes.IsStatic) {
+					classBlock.AppendGeneratedCodeAttribute (optimizable: true);
+					classBlock.WriteLine (
+						$"static readonly {NativeHandle} {ClassPtr} = {BindingSyntaxFactory.Class}.GetHandle (\"{registrationName}\");");
+					classBlock.WriteLine ();
+					classBlock.WriteDocumentation (Documentation.Class.ClassHandle (bindingContext.Changes.Name));
+					classBlock.WriteLine ($"public override {NativeHandle} ClassHandle => {ClassPtr};");
+					classBlock.WriteLine ();
+
+					EmitDefaultConstructors (bindingContext: bindingContext,
+						classBlock: classBlock,
+						disableDefaultCtor: bindingData.Flags.HasFlag (ObjCBindings.Class.DisableDefaultCtor));
+
+					// emit any other constructor that is not the default one
+					EmitConstructors (bindingContext, classBlock);
+				}
+
+				EmitFields (bindingContext.Changes.Name, bindingContext.Changes.Properties, classBlock,
+					out var notificationProperties);
+				EmitProperties (bindingContext, classBlock);
+				this.EmitMethods (bindingContext, classBlock);
 
-			// emit the notification helper classes, leave this for the very bottom of the class
-			EmitNotifications (notificationProperties, classBlock);
-		}
+				// emit the notification helper classes, leave this for the very bottom of the class
+				EmitNotifications (notificationProperties, classBlock);
+			}
 
-		// close the outer classes since we used a LinkedList to store them and insert them at the head, we can
-		// simply dispose them in current order, which is the reverse of the creation order
-		foreach (var outerClassesBuilder in outerClassesBuilders) {
-			outerClassesBuilder.Dispose ();
+			return true;
 		}
-		return true;
 	}
 }

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

@@ -171,7 +171,7 @@ void EmitExtensionMethods (TabbedWriter<StringWriter> classBlock, string symbolN
 	/// <param name="bindingContext">The current binding context.</param>
 	/// <param name="diagnostics">Out parameter with the error diagnostics.</param>
 	/// <returns>True if the binding was generated, false otherwise.</returns>
-	bool TryEmitSmartEnum (in BindingTypeData<SmartEnum> _, in BindingContext bindingContext, [NotNullWhen (false)] out ImmutableArray<Diagnostic>? diagnostics)
+	bool TryEmitSmartEnum (in BindingContext bindingContext, [NotNullWhen (false)] out ImmutableArray<Diagnostic>? diagnostics)
 	{
 		diagnostics = null;
 		if (bindingContext.Changes.BindingType != BindingType.SmartEnum) {
@@ -184,34 +184,36 @@ bool TryEmitSmartEnum (in BindingTypeData<SmartEnum> _, in BindingContext bindin
 		}
 		// in the old generator we had to copy over the enum, in this new approach, the only code
 		// we need to create is the extension class for the enum that is backed by fields
-		bindingContext.Builder.WriteLine ();
-		bindingContext.Builder.WriteLine ($"namespace {string.Join (".", bindingContext.Changes.Namespace)};");
-		bindingContext.Builder.WriteLine ();
-
-		var symbolName = GetSymbolName (bindingContext.Changes);
-		var extensionClassDeclaration =
-			bindingContext.Changes.ToSmartEnumExtensionDeclaration (symbolName);
-
-		bindingContext.Builder.WriteDocumentation (Documentation.SmartEnum.ClassDocumentation (symbolName));
-		bindingContext.Builder.AppendMemberAvailability (bindingContext.Changes.SymbolAvailability);
-		bindingContext.Builder.AppendGeneratedCodeAttribute ();
-		using (var classBlock = bindingContext.Builder.CreateBlock (extensionClassDeclaration.ToString (), true)) {
-			classBlock.WriteLine ();
-			classBlock.WriteLine ($"static IntPtr[] values = new IntPtr [{bindingContext.Changes.EnumMembers.Length}];");
-			// foreach member in the enum we need to create a field that holds the value, the property emitter
-			// will take care of generating the property. Do not order it by name to keep the order of the enum
-			if (!TryEmit (classBlock, bindingContext.Changes)) {
-				diagnostics = []; // empty diagnostics since it was a user error
-				return false;
+		this.EmitNamespace (bindingContext);
+
+		using (var _ = this.EmitOuterClasses (bindingContext, out var builder)) {
+			var symbolName = GetSymbolName (bindingContext.Changes);
+			var extensionClassDeclaration =
+				bindingContext.Changes.ToSmartEnumExtensionDeclaration (symbolName);
+
+			builder.WriteDocumentation (Documentation.SmartEnum.ClassDocumentation (symbolName));
+			builder.AppendMemberAvailability (bindingContext.Changes.SymbolAvailability);
+			builder.AppendGeneratedCodeAttribute ();
+			using (var classBlock = builder.CreateBlock (extensionClassDeclaration.ToString (), true)) {
+				classBlock.WriteLine ();
+				classBlock.WriteLine (
+					$"static IntPtr[] values = new IntPtr [{bindingContext.Changes.EnumMembers.Length}];");
+				// foreach member in the enum we need to create a field that holds the value, the property emitter
+				// will take care of generating the property. Do not order it by name to keep the order of the enum
+				if (!TryEmit (classBlock, bindingContext.Changes)) {
+					diagnostics = []; // empty diagnostics since it was a user error
+					return false;
+				}
+
+				classBlock.WriteLine ();
+
+				// emit the extension methods that will be used to get the values from the enum
+				EmitExtensionMethods (classBlock, symbolName, bindingContext.Changes);
+				classBlock.WriteLine ();
 			}
-			classBlock.WriteLine ();
 
-			// emit the extension methods that will be used to get the values from the enum
-			EmitExtensionMethods (classBlock, symbolName, bindingContext.Changes);
-			classBlock.WriteLine ();
+			return true;
 		}
-
-		return true;
 	}
 
 	bool TryEmitErrorCode (in BindingTypeData<SmartEnum> bindingTypeData, in BindingContext bindingContext, [NotNullWhen (false)] out ImmutableArray<Diagnostic>? diagnostics)
@@ -252,35 +254,36 @@ bool TryEmitErrorCode (in BindingTypeData<SmartEnum> bindingTypeData, in Binding
 
 		var library = libraryPath ?? libraryName;
 
-		bindingContext.Builder.WriteLine ();
-		bindingContext.Builder.WriteLine ($"namespace {string.Join (".", bindingContext.Changes.Namespace)};");
-		bindingContext.Builder.WriteLine ();
-
-		bindingContext.Builder.AppendMemberAvailability (bindingContext.Changes.SymbolAvailability);
-		bindingContext.Builder.AppendGeneratedCodeAttribute ();
-		var extensionClassDeclaration =
-			bindingContext.Changes.ToSmartEnumExtensionDeclaration (GetSymbolName (bindingContext.Changes));
-
-		using (var classBlock = bindingContext.Builder.CreateBlock (extensionClassDeclaration.ToString (), true)) {
-			classBlock.WriteLine ();
-			// emit the field that holds the error domain
-			classBlock.WriteLine ($"[Field (\"{bindingTypeData.ErrorDomain}\", \"{library}\")]");
-			classBlock.WriteLine (StaticVariable (backingFieldName, NSString, true).ToString ());
-			classBlock.WriteLine ();
-
-			// emit the extension method to return the error domain
-			classBlock.WriteDocumentation (Documentation.SmartEnum.GetDomain (bindingContext.Changes.FullyQualifiedSymbol));
-			classBlock.WriteRaw (
-$@"public static {NSString}? GetDomain (this {bindingContext.Changes.Name.GetIdentifierName (bindingContext.Changes.Namespace)} self)
+		this.EmitNamespace (bindingContext);
+
+		using (var _ = this.EmitOuterClasses (bindingContext, out var builder)) {
+			builder.AppendMemberAvailability (bindingContext.Changes.SymbolAvailability);
+			builder.AppendGeneratedCodeAttribute ();
+			var extensionClassDeclaration =
+				bindingContext.Changes.ToSmartEnumExtensionDeclaration (GetSymbolName (bindingContext.Changes));
+
+			using (var classBlock = builder.CreateBlock (extensionClassDeclaration.ToString (), true)) {
+				classBlock.WriteLine ();
+				// emit the field that holds the error domain
+				classBlock.WriteLine ($"[Field (\"{bindingTypeData.ErrorDomain}\", \"{library}\")]");
+				classBlock.WriteLine (StaticVariable (backingFieldName, NSString, true).ToString ());
+				classBlock.WriteLine ();
+
+				// emit the extension method to return the error domain
+				classBlock.WriteDocumentation (
+					Documentation.SmartEnum.GetDomain (bindingContext.Changes.FullyQualifiedSymbol));
+				classBlock.WriteRaw (
+					$@"public static {NSString}? GetDomain (this {bindingContext.Changes.Name.GetIdentifierName (bindingContext.Changes.Namespace)} self)
 {{
 	if ({backingFieldName} is null)
 		{backingFieldName} = {Dlfcn}.GetStringConstant ({Libraries}.{libraryName}.Handle, ""{bindingTypeData.ErrorDomain}"");
 	return {backingFieldName};
 }}
 ");
-		}
+			}
 
-		return true;
+			return true;
+		}
 	}
 
 	public bool TryEmit (in BindingContext bindingContext, [NotNullWhen (false)] out ImmutableArray<Diagnostic>? diagnostics)
@@ -292,6 +295,6 @@ public bool TryEmit (in BindingContext bindingContext, [NotNullWhen (false)] out
 
 		return bindingData.Flags.HasFlag (SmartEnum.ErrorCode)
 			? TryEmitErrorCode (bindingData, bindingContext, out diagnostics)
-			: TryEmitSmartEnum (bindingData, bindingContext, out diagnostics);
+			: TryEmitSmartEnum (bindingContext, out diagnostics);
 	}
 }

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

@@ -1,11 +1,16 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
+
+using System;
+using System.Collections;
 using System.Collections.Generic;
 using System.Collections.Immutable;
 using System.Diagnostics.CodeAnalysis;
+using System.IO;
 using Microsoft.CodeAnalysis;
 using Microsoft.Macios.Generator.Context;
 using Microsoft.Macios.Generator.DataModel;
+using Microsoft.Macios.Generator.IO;
 
 namespace Microsoft.Macios.Generator.Emitters;
 
@@ -33,3 +38,60 @@ interface ICodeEmitter {
 	/// </summary>
 	IEnumerable<string> UsingStatements { get; }
 }
+
+static class ICodeEmitterExtensions {
+
+	/// <summary>
+	/// Helper class to manage the disposal of the writers for the outer classes.
+	/// </summary>
+	class Blocks (LinkedList<TabbedWriter<StringWriter>> blocks) : IDisposable {
+		public void Dispose ()
+		{
+			// close the outer classes since we used a LinkedList to store them and insert them at the head, we can
+			// simply dispose them in current order, which is the reverse of the creation order
+			foreach (var outerClassesBuilder in blocks) {
+				outerClassesBuilder.Dispose ();
+			}
+		}
+	}
+
+	/// <summary>
+	/// Emits the namespace declaration for the binding.
+	/// </summary>
+	/// <param name="self">The code emitter.</param>
+	/// <param name="bindingContext">The context for the binding.</param>
+	public static void EmitNamespace (this ICodeEmitter self, in BindingContext bindingContext)
+	{
+		bindingContext.Builder.WriteLine ();
+		bindingContext.Builder.WriteLine ($"namespace {string.Join (".", bindingContext.Changes.Namespace)};");
+		bindingContext.Builder.WriteLine ();
+	}
+
+	/// <summary>
+	/// Emits the outer classes for the binding.
+	/// </summary>
+	/// <param name="self">The code emitter.</param>
+	/// <param name="bindingContext">The context for the binding.</param>
+	/// <param name="builder">The tabbed writer for the innermost class.</param>
+	/// <returns>An <see cref="IDisposable"/> that will close the outer classes blocks when disposed.</returns>
+	public static IDisposable EmitOuterClasses (this ICodeEmitter self, in BindingContext bindingContext,
+		out TabbedWriter<StringWriter> builder)
+	{
+		// if the type of the change contains outer classes, we need to emit the outer classes first
+		builder = bindingContext.Builder;
+		// create a list for the outer classes builders so that we can dispose them later, we are using a linked list
+		// because AddFirst is O(1) and we need to dispose them in the reverse order of creation
+		var outerClassesBuilders = new LinkedList<TabbedWriter<StringWriter>> ();
+		if (bindingContext.Changes.OuterClasses.Length > 0) {
+			// emit the outer classes and set the builder to the innermost class
+			foreach (var outerClass in bindingContext.Changes.OuterClasses) {
+				var outerModifiers = $"{string.Join (' ', outerClass.Modifiers)} ";
+				builder = builder.CreateBlock ($"{(string.IsNullOrWhiteSpace (outerModifiers) ? string.Empty : outerModifiers)}class {outerClass.Name}", true);
+				// add the current builder to the list so that we can dispose it later, we add it to the head of the
+				// list so that we can dispose it in the reverse order of creation
+				outerClassesBuilders.AddFirst (builder);
+			}
+		}
+		return new Blocks (outerClassesBuilders);
+	}
+}