[RGen] Generate the strong dictionary Keys. (#23403)

Add a generator for the strong dictionary keys. This does generator does
not generate the backwards compatible code, that will be performed by
another generator that can be easily disabled.

---------

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

Author: 3 people

src/rgen/Microsoft.Macios.Generator/AttributesNames.cs

@@ -16,6 +16,7 @@ static class AttributesNames {
 	public const string BindFromAttribute = "ObjCBindings.BindFromAttribute";
 	public const string ProtocolAttribute = "ObjCBindings.BindingTypeAttribute<ObjCBindings.Protocol>";
 	public const string StrongDictionaryAttribute = "ObjCBindings.BindingTypeAttribute<ObjCBindings.StrongDictionary>";
+	public const string StrongDictionaryKeysAttribute = "ObjCBindings.BindingTypeAttribute<ObjCBindings.StrongDictionaryKeys>";
 	public const string FieldAttribute = "ObjCBindings.FieldAttribute";
 	public const string EnumFieldAttribute = "ObjCBindings.FieldAttribute<ObjCBindings.EnumValue>";
 	public const string FieldPropertyAttribute = "ObjCBindings.FieldAttribute<ObjCBindings.Property>";
@@ -36,6 +37,7 @@ static class AttributesNames {
 		ClassAttribute,
 		ProtocolAttribute,
 		StrongDictionaryAttribute,
+		StrongDictionaryKeysAttribute,
 		CoreImageFilterAttribute,
 		SmartEnumAttribute,
 	];
@@ -56,6 +58,9 @@ static class AttributesNames {
 		if (type == typeof (ObjCBindings.StrongDictionary)) {
 			return StrongDictionaryAttribute;
 		}
+		if (type == typeof (ObjCBindings.StrongDictionaryKeys)) {
+			return StrongDictionaryKeysAttribute;
+		}
 		if (type == typeof (ObjCBindings.SmartEnum)) {
 			return SmartEnumAttribute;
 		}

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

@@ -21,6 +21,7 @@ namespace Microsoft.Macios.Generator.DataModel;
 	[FieldOffset (8)] readonly BindingTypeData<ObjCBindings.CoreImageFilter> coreImageFilterData;
 	[FieldOffset (8)] readonly BindingTypeData<ObjCBindings.SmartEnum> smartEnumData;
 	[FieldOffset (8)] readonly BindingTypeData<ObjCBindings.StrongDictionary> strongDictionaryData;
+	[FieldOffset (8)] readonly BindingTypeData<ObjCBindings.StrongDictionaryKeys> strongDictionaryKeysData;
 
 	/// <summary>
 	/// The type of the binding.
@@ -112,6 +113,16 @@ public BindingInfo (BindingTypeData<ObjCBindings.StrongDictionary> data)
 		strongDictionaryData = data;
 	}
 
+	/// <summary>
+	/// Initializes a new instance of the <see cref="BindingInfo"/> struct for a strong dictionary keys binding.
+	/// </summary>
+	/// <param name="data">The strong dictionary keys binding data.</param>
+	public BindingInfo (BindingTypeData<ObjCBindings.StrongDictionaryKeys> data)
+	{
+		bindingType = BindingType.StrongDictionaryKeys;
+		strongDictionaryKeysData = data;
+	}
+
 	/// <summary>
 	/// Implicitly converts a <see cref="BindingInfo"/> to a <see cref="BindingTypeData"/>.
 	/// </summary>
@@ -190,6 +201,18 @@ public BindingInfo (BindingTypeData<ObjCBindings.StrongDictionary> data)
 		return info.strongDictionaryData;
 	}
 
+	/// <summary>
+	/// Implicitly converts a <see cref="BindingInfo"/> to a <see cref="BindingTypeData{T}"/> for a strong dictionary keys.
+	/// </summary>
+	/// <param name="info">The <see cref="BindingInfo"/> to convert.</param>
+	/// <exception cref="InvalidCastException">Thrown if the binding type is not <see cref="BindingType.StrongDictionaryKeys"/>.</exception>
+	public static implicit operator BindingTypeData<ObjCBindings.StrongDictionaryKeys> (BindingInfo info)
+	{
+		if (info.BindingType != BindingType.StrongDictionaryKeys)
+			throw new InvalidCastException ($"Invalid cast to ObjCBindings.StrongDictionaryKeys for binding type {info.BindingType}");
+		return info.strongDictionaryKeysData;
+	}
+
 	/// <summary>
 	/// Implicitly converts a <see cref="BindingTypeData"/> to a <see cref="BindingInfo"/>.
 	/// </summary>
@@ -225,6 +248,11 @@ public BindingInfo (BindingTypeData<ObjCBindings.StrongDictionary> data)
 	/// </summary>
 	/// <param name="data">The <see cref="BindingTypeData{T}"/> to convert.</param>
 	public static implicit operator BindingInfo (BindingTypeData<ObjCBindings.StrongDictionary> data) => new (data);
+	/// <summary>
+	/// Implicitly converts a <see cref="BindingTypeData{T}"/> for a strong dictionary keys to a <see cref="BindingInfo"/>.
+	/// </summary>
+	/// <param name="data">The <see cref="BindingTypeData{T}"/> to convert.</param>
+	public static implicit operator BindingInfo (BindingTypeData<ObjCBindings.StrongDictionaryKeys> data) => new (data);
 
 	/// <inheritdoc />
 	public bool Equals (BindingInfo other)
@@ -244,6 +272,8 @@ public bool Equals (BindingInfo other)
 			return categoryData == other.categoryData;
 		case BindingType.StrongDictionary:
 			return strongDictionaryData == other.strongDictionaryData;
+		case BindingType.StrongDictionaryKeys:
+			return strongDictionaryKeysData == other.strongDictionaryKeysData;
 		}
 		return false;
 	}
@@ -261,6 +291,7 @@ public override bool Equals (object? obj)
 		BindingType.Protocol => HashCode.Combine (bindingType, protocolData),
 		BindingType.Category => HashCode.Combine (bindingType, categoryData),
 		BindingType.StrongDictionary => HashCode.Combine (bindingType, strongDictionaryData),
+		BindingType.StrongDictionaryKeys => HashCode.Combine (bindingType, strongDictionaryKeysData),
 		_ => HashCode.Combine (bindingType, bindingTypeData)
 	};
 
@@ -294,6 +325,7 @@ public override bool Equals (object? obj)
 		BindingType.CoreImageFilter => $"{{ BindingType: {bindingType}, BindingData: {coreImageFilterData} }}",
 		BindingType.SmartEnum => $"{{ BindingType: {bindingType}, BindingData: {smartEnumData} }}",
 		BindingType.StrongDictionary => $"{{ BindingType: {bindingType}, BindingData: {strongDictionaryData} }}",
+		BindingType.StrongDictionaryKeys => $"{{ BindingType: {bindingType}, BindingData: {strongDictionaryKeysData} }}",
 		_ => throw new NotImplementedException ()
 	};
 }

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

@@ -32,6 +32,10 @@ enum BindingType : ulong {
 	/// </summary>
 	StrongDictionary,
 	/// <summary>
+	/// Binding type for strong dictionary keys.
+	/// </summary>
+	StrongDictionaryKeys,
+	/// <summary>
 	/// Binding type for a core image filter.
 	/// </summary>
 	CoreImageFilter,

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

@@ -25,7 +25,14 @@ namespace Microsoft.Macios.Generator.Emitters;
 /// </summary>
 class ClassEmitter : IClassEmitter {
 	/// <inheritdoc />
-	public string GetSymbolName (in Binding binding) => binding.Name;
+	public string GetSymbolName (in Binding binding)
+	{
+		var outerClasses = binding.OuterClasses.Select (x => x.Name);
+		var prefix = string.Join ('.', outerClasses);
+		return string.IsNullOrEmpty (prefix)
+			? binding.Name
+			: $"{prefix}.{binding.Name}";
+	}
 
 	/// <inheritdoc />
 	public IEnumerable<string> UsingStatements => [
@@ -124,85 +131,6 @@ void EmitConstructors (in BindingContext context, TabbedWriter<StringWriter> cla
 		}
 	}
 
-	/// <summary>
-	/// Emit the code for all the field properties in the class. The code will add any necessary backing fields and
-	/// will return all properties that are notifications.
-	/// </summary>
-	/// <param name="className">The current class name.</param>
-	/// <param name="properties">All properties of the class, the method will filter those that are fields.</param>
-	/// <param name="classBlock">Current class block.</param>
-	/// <param name="notificationProperties">An immutable array with all the properties that are marked as notifications
-	/// and that need a helper class to be generated.</param>
-	void EmitFields (string className, in ImmutableArray<Property> properties, TabbedWriter<StringWriter> classBlock,
-		out ImmutableArray<Property> notificationProperties)
-	{
-		var notificationsBuilder = ImmutableArray.CreateBuilder<Property> ();
-		foreach (var property in properties.OrderBy (p => p.Name)) {
-			if (!property.IsField)
-				continue;
-
-			classBlock.WriteLine ();
-			// a field should always have a getter, if it does not, we do not generate the property
-			var getter = property.GetAccessor (AccessorKind.Getter);
-			if (getter is null)
-				continue;
-
-			// provide a backing variable for the property if and only if we are dealing with a reference type
-			if (property.IsReferenceType) {
-				classBlock.WriteLine (FieldPropertyBackingVariable (property).ToString ());
-			}
-
-			classBlock.WriteLine ();
-			classBlock.AppendMemberAvailability (property.SymbolAvailability);
-			classBlock.AppendGeneratedCodeAttribute (optimizable: true);
-			if (property.IsNotification) {
-				// add it to the bucket so that we can later generate the necessary partial class for the 
-				// notifications
-				notificationsBuilder.Add (property);
-				classBlock.AppendNotificationAdvice (className, property.Name);
-			}
-
-			using (var propertyBlock = classBlock.CreateBlock (property.ToDeclaration ().ToString (), block: true)) {
-				// generate the accessors, we will always have a get, a set is optional depending on the type
-				// if the symbol availability of the accessor is different of the one from the property, write it
-				var backingField = property.BackingField;
-
-				// be very verbose with the availability, makes the life easier to the dotnet analyzer
-				propertyBlock.AppendMemberAvailability (getter.Value.SymbolAvailability);
-				using (var getterBlock = propertyBlock.CreateBlock ("get", block: true)) {
-					// fields with a reference type have a backing fields, while value types do not
-					if (property.IsReferenceType) {
-						getterBlock.WriteRaw (
-$@"if ({backingField} is null)
-	{backingField} = {ExpressionStatement (FieldConstantGetter (property))}
-return {backingField};
-");
-					} else {
-						// directly return the call from the getter
-						getterBlock.WriteLine ($"return {ExpressionStatement (FieldConstantGetter (property))}");
-					}
-				}
-
-				var setter = property.GetAccessor (AccessorKind.Setter);
-				if (setter is null)
-					// we are done with the current property
-					continue;
-
-				propertyBlock.WriteLine (); // add space between getter and setter since we have the attrs
-				propertyBlock.AppendMemberAvailability (setter.Value.SymbolAvailability);
-				using (var setterBlock = propertyBlock.CreateBlock ("set", block: true)) {
-					if (property.IsReferenceType) {
-						// set the backing field
-						setterBlock.WriteLine ($"{backingField} = value;");
-					}
-					// call the native code
-					setterBlock.WriteLine ($"{ExpressionStatement (FieldConstantSetter (property, "value"))}");
-				}
-			}
-		}
-		notificationProperties = notificationsBuilder.ToImmutable ();
-	}
-
 	/// <summary>
 	/// Emit the code for all the properties in the class.
 	/// </summary>
@@ -441,7 +369,7 @@ public bool TryEmit (in BindingContext bindingContext, [NotNullWhen (false)] out
 					EmitConstructors (bindingContext, classBlock);
 				}
 
-				EmitFields (bindingContext.Changes.Name, bindingContext.Changes.Properties, classBlock,
+				this.EmitFields (bindingContext.Changes.Name, bindingContext.Changes.Properties, classBlock,
 					out var notificationProperties);
 				EmitProperties (bindingContext, classBlock);
 				this.EmitMethods (bindingContext, classBlock);

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

@@ -1,6 +1,7 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 
+using System.Collections.Immutable;
 using System.IO;
 using System.Linq;
 using Microsoft.Macios.Generator.Context;
@@ -220,4 +221,83 @@ public static void EmitMethods (this IClassEmitter self, in BindingContext conte
 		}
 	}
 
+	/// <summary>
+	/// Emit the code for all the field properties in the class. The code will add any necessary backing fields and
+	/// will return all properties that are notifications.
+	/// </summary>
+	/// <param name="self"></param>
+	/// <param name="className">The current class name.</param>
+	/// <param name="properties">All properties of the class, the method will filter those that are fields.</param>
+	/// <param name="classBlock">Current class block.</param>
+	/// <param name="notificationProperties">An immutable array with all the properties that are marked as notifications
+	/// and that need a helper class to be generated.</param>
+	public static void EmitFields (this IClassEmitter self, string className, in ImmutableArray<Property> properties, TabbedWriter<StringWriter> classBlock,
+		out ImmutableArray<Property> notificationProperties)
+	{
+		var notificationsBuilder = ImmutableArray.CreateBuilder<Property> ();
+		foreach (var property in properties.OrderBy (p => p.Name)) {
+			if (!property.IsField)
+				continue;
+
+			classBlock.WriteLine ();
+			// a field should always have a getter, if it does not, we do not generate the property
+			var getter = property.GetAccessor (AccessorKind.Getter);
+			if (getter is null)
+				continue;
+
+			// provide a backing variable for the property if and only if we are dealing with a reference type
+			if (property.IsReferenceType) {
+				classBlock.WriteLine (FieldPropertyBackingVariable (property).ToString ());
+			}
+
+			classBlock.WriteLine ();
+			classBlock.AppendMemberAvailability (property.SymbolAvailability);
+			classBlock.AppendGeneratedCodeAttribute (optimizable: true);
+			if (property.IsNotification) {
+				// add it to the bucket so that we can later generate the necessary partial class for the 
+				// notifications
+				notificationsBuilder.Add (property);
+				classBlock.AppendNotificationAdvice (className, property.Name);
+			}
+
+			using (var propertyBlock = classBlock.CreateBlock (property.ToDeclaration ().ToString (), block: true)) {
+				// generate the accessors, we will always have a get, a set is optional depending on the type
+				// if the symbol availability of the accessor is different of the one from the property, write it
+				var backingField = property.BackingField;
+
+				// be very verbose with the availability, makes the life easier to the dotnet analyzer
+				propertyBlock.AppendMemberAvailability (getter.Value.SymbolAvailability);
+				using (var getterBlock = propertyBlock.CreateBlock ("get", block: true)) {
+					// fields with a reference type have a backing fields, while value types do not
+					if (property.IsReferenceType) {
+						getterBlock.WriteRaw (
+$@"if ({backingField} is null)
+	{backingField} = {ExpressionStatement (FieldConstantGetter (property))}
+return {backingField};
+");
+					} else {
+						// directly return the call from the getter
+						getterBlock.WriteLine ($"return {ExpressionStatement (FieldConstantGetter (property))}");
+					}
+				}
+
+				var setter = property.GetAccessor (AccessorKind.Setter);
+				if (setter is null)
+					// we are done with the current property
+					continue;
+
+				propertyBlock.WriteLine (); // add space between getter and setter since we have the attrs
+				propertyBlock.AppendMemberAvailability (setter.Value.SymbolAvailability);
+				using (var setterBlock = propertyBlock.CreateBlock ("set", block: true)) {
+					if (property.IsReferenceType) {
+						// set the backing field
+						setterBlock.WriteLine ($"{backingField} = value;");
+					}
+					// call the native code
+					setterBlock.WriteLine ($"{ExpressionStatement (FieldConstantSetter (property, "value"))}");
+				}
+			}
+		}
+		notificationProperties = notificationsBuilder.ToImmutable ();
+	}
 }

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

@@ -16,7 +16,8 @@ static class EmitterFactory {
 		{ BindingType.SmartEnum, new EnumEmitter () },
 		{ BindingType.Protocol, new InterfaceEmitter () },
 		{ BindingType.Category, new CategoryEmitter () },
-		{ BindingType.StrongDictionary, new StrongDictionaryEmitter () }
+		{ BindingType.StrongDictionary, new StrongDictionaryEmitter () },
+		{ BindingType.StrongDictionaryKeys, new StrongDictionaryKeysEmitter () }
 	};
 	public static bool TryCreate (Binding changes, [NotNullWhen (true)] out ICodeEmitter? emitter)
 		=> emitters.TryGetValue (changes.BindingType, out emitter);

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

@@ -0,0 +1,63 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq;
+using Microsoft.CodeAnalysis;
+using Microsoft.Macios.Generator.Context;
+using Microsoft.Macios.Generator.DataModel;
+using Microsoft.Macios.Generator.IO;
+
+namespace Microsoft.Macios.Generator.Emitters;
+
+/// <summary>
+/// Emitter responsible for generating strong dictionary keys classes.
+/// </summary>
+class StrongDictionaryKeysEmitter : IClassEmitter {
+
+	/// <inheritdoc />
+	public string GetSymbolName (in Binding binding)
+	{
+		var outerClasses = binding.OuterClasses.Select (x => x.Name);
+		var prefix = string.Join ('.', outerClasses);
+		return string.IsNullOrEmpty (prefix)
+			? binding.Name
+			: $"{prefix}.{binding.Name}";
+	}
+
+	/// <inheritdoc />
+	public IEnumerable<string> UsingStatements { get; } = [];
+
+	/// <inheritdoc />
+	public bool TryEmit (in BindingContext bindingContext, [NotNullWhen (false)] out ImmutableArray<Diagnostic>? diagnostics)
+	{
+		diagnostics = null;
+		if (bindingContext.Changes.BindingType != BindingType.StrongDictionaryKeys) {
+			diagnostics = [Diagnostic.Create (
+				Diagnostics
+					.RBI0000, // An unexpected error occurred while processing '{0}'. Please fill a bug report at https://github.com/dotnet/macios/issues/new.
+				null,
+				bindingContext.Changes.FullyQualifiedSymbol)];
+			return false;
+		}
+
+		// namespace declaration
+		this.EmitNamespace (bindingContext);
+
+		using (var _ = this.EmitOuterClasses (bindingContext, out var builder)) {
+			builder.AppendMemberAvailability (bindingContext.Changes.SymbolAvailability);
+			var modifiers = $"{string.Join (' ', bindingContext.Changes.Modifiers)} ";
+			using (var classBlock = builder.CreateBlock (
+					   $"{(string.IsNullOrWhiteSpace (modifiers) ? string.Empty : modifiers)}class {bindingContext.Changes.Name}",
+					   true)) {
+				// the only thing we care about is the keys, so we emit the keys
+				this.EmitFields (bindingContext.Changes.Name, bindingContext.Changes.Properties, classBlock,
+					out var _);
+			}
+		}
+		return true;
+	}
+
+}