[bgen] Fix generating delegates with nullable return types. #17109. (#21094)

Fixes #17109.

Author: rolfbjarne

src/bgen/Generator.cs

@@ -1628,7 +1628,7 @@ void GenerateTrampolinesForQueue (TrampolineInfo [] queue)
 			} else {
 				if (ti.Convert.Length > 0)
 					print (ti.Convert);
-				print ("{0} retval = del ({1});", ti.DelegateReturnType, ti.Invoke);
+				print ("var retval = del ({1});", ti.DelegateReturnType, ti.Invoke);
 				if (ti.PostConvert.Length > 0)
 					print (ti.PostConvert);
 				print (ti.ReturnFormat, "retval");
@@ -6645,7 +6645,7 @@ public void Generate (Type type)
 						if (isProtocolEventBacked)
 							print ("[Export (\"{0}\")]", FindSelector (dtype, mi));
 
-						print ("public {0}{1} {2} ({3})", shouldOverrideDelegateString, TypeManager.RenderType (mi.ReturnType), mi.Name, RenderParameterDecl (pars));
+						print ("public {0}{1} {2} ({3})", shouldOverrideDelegateString, TypeManager.RenderType (mi.ReturnType, mi.ReturnTypeCustomAttributes), mi.Name, RenderParameterDecl (pars));
 						print ("{"); indent++;
 
 						if (mi.Name == bta.KeepRefUntil)
@@ -7451,8 +7451,6 @@ string RenderSingleParameter (ParameterInfo p, bool removeRefTypes)
 			name += (removeRefTypes ? "" : (p.IsOut ? "out " : "ref ")) + TypeManager.RenderType (pt, p);
 		} else
 			name += TypeManager.RenderType (pt, p);
-		if (!pt.IsValueType && AttributeManager.HasAttribute<NullAllowedAttribute> (p))
-			name += "?";
 		return name;
 	}
 

src/bgen/TypeManager.cs

@@ -256,61 +256,65 @@ public string FormatTypeUsedIn (string? usedInNamespace, Type? type)
 
 	public string? RenderType (Type t, ICustomAttributeProvider? provider = null)
 	{
+		var nullable = string.Empty;
+		if (provider is not null && !t.IsValueType && AttributeManager.HasAttribute<NullAllowedAttribute> (provider))
+			nullable = "?";
+
 		if (!t.IsEnum) {
 			switch (Type.GetTypeCode (t)) {
 			case TypeCode.Char:
-				return "char";
+				return "char" + nullable;
 			case TypeCode.String:
-				return "string";
+				return "string" + nullable;
 			case TypeCode.Int32:
-				return "int";
+				return "int" + nullable;
 			case TypeCode.UInt32:
-				return "uint";
+				return "uint" + nullable;
 			case TypeCode.Int64:
-				return "long";
+				return "long" + nullable;
 			case TypeCode.UInt64:
-				return "ulong";
+				return "ulong" + nullable;
 			case TypeCode.Single:
-				return "float";
+				return "float" + nullable;
 			case TypeCode.Double:
-				return "double";
+				return "double" + nullable;
 			case TypeCode.Decimal:
-				return "decimal";
+				return "decimal" + nullable;
 			case TypeCode.SByte:
-				return "sbyte";
+				return "sbyte" + nullable;
 			case TypeCode.Byte:
-				return "byte";
+				return "byte" + nullable;
 			case TypeCode.Boolean:
-				return "bool";
+				return "bool" + nullable;
 			}
 		}
 
 		if (t == TypeCache.System_Void)
 			return "void";
 
 		if (t == TypeCache.System_IntPtr) {
-			return AttributeManager.HasNativeAttribute (provider) ? "nint" : "IntPtr";
+			return (AttributeManager.HasNativeAttribute (provider) ? "nint" : "IntPtr") + nullable;
 		} else if (t == TypeCache.System_UIntPtr) {
-			return AttributeManager.HasNativeAttribute (provider) ? "nuint" : "UIntPtr";
+			return (AttributeManager.HasNativeAttribute (provider) ? "nuint" : "UIntPtr") + nullable;
 		}
 
 		if (t.Namespace is not null) {
 			string ns = t.Namespace;
 			if (NamespaceCache.ImplicitNamespaces.Contains (ns) || t.IsGenericType) {
 				var targs = t.GetGenericArguments ();
 				if (targs.Length == 0)
-					return t.Name;
-				return $"global::{t.Namespace}." + t.Name.RemoveArity () + "<" + string.Join (", ", targs.Select (l => FormatTypeUsedIn (null, l)).ToArray ()) + ">";
+					return t.Name + nullable;
+				return $"global::{t.Namespace}." + t.Name.RemoveArity () + "<" + string.Join (", ", targs.Select (l => FormatTypeUsedIn (null, l)).ToArray ()) + ">" + nullable;
 			}
 			if (NamespaceCache.NamespacesThatConflictWithTypes.Contains (ns))
-				return "global::" + t.FullName;
+				return "global::" + t.FullName + nullable;
 			if (t.Name == t.Namespace)
-				return "global::" + t.FullName;
+				return "global::" + t.FullName + nullable;
 			else
-				return t.FullName;
+				return t.FullName + nullable;
 		}
 
-		return t.FullName;
+		return t.FullName + nullable;
 	}
 
 	// TODO: If we ever have an API with nested properties of the same name more than

tests/generator/BGenTests.cs

@@ -1657,5 +1657,16 @@ public void BackingFieldType (Profile profile)
 			Assert.AreEqual (nuintName, nsNSUIntegerGetValue.Parameters [0].ParameterType.FullName, "NSUInteger #2");
 		}
 
+		[Test]
+		[TestCase (Profile.iOS)]
+		public void DelegatesWithNullableReturnType (Profile profile)
+		{
+			Configuration.IgnoreIfIgnoredPlatform (profile.AsPlatform ());
+			var bgen = BuildFile (profile, "tests/delegate-nullable-return.cs");
+			bgen.AssertNoWarnings ();
+
+			var delegateCallback = bgen.ApiAssembly.MainModule.GetType ("NS", "MyCallback").Methods.First ((v) => v.Name == "EndInvoke");
+			Assert.That (delegateCallback.MethodReturnType.CustomAttributes.Any (v => v.AttributeType.Name == "NullableAttribute"), "Nullable return type");
+		}
 	}
 }

tests/generator/tests/delegate-nullable-return.cs

@@ -0,0 +1,16 @@
+using System;
+
+using Foundation;
+using ObjCRuntime;
+
+namespace NS {
+	[return: NullAllowed]
+	delegate NSObject MyCallback ([NullAllowed] NSObject obj);
+
+	[BaseType (typeof (NSObject))]
+	interface Widget {
+		[Export ("foo")]
+		[NullAllowed]
+		MyCallback Foo { get; set; }
+	}
+}