add workaround for by-ref parameter types

Author: smdn

src/Smdn.Reflection.ReverseGenerating/Smdn.Reflection.ReverseGenerating/CSharpTypeFormatter.FormatTypeNameWithNullabilityAnnotation.cs

@@ -15,6 +15,22 @@ namespace Smdn.Reflection.ReverseGenerating;
 #pragma warning disable IDE0040
 static partial class CSharpFormatter {
 #pragma warning restore IDE0040
+  // Workaround: The pseudo ParameterInfo type which unwraps 'ByRef' type to its element type
+  // See https://github.com/dotnet/runtime/issues/72320
+  private sealed class ByRefElementTypeParameterInfo : ParameterInfo {
+    public ParameterInfo BaseParameter { get; }
+
+    public ByRefElementTypeParameterInfo(ParameterInfo baseParam)
+    {
+      BaseParameter = baseParam;
+    }
+
+    public override MemberInfo Member => BaseParameter.Member;
+    public override Type ParameterType => BaseParameter.ParameterType.GetElementType()!;
+    public override IList<CustomAttributeData> GetCustomAttributesData()
+      => BaseParameter.GetCustomAttributesData();
+  }
+
   private static StringBuilder FormatTypeNameWithNullabilityAnnotation(
     NullabilityInfo target,
     StringBuilder builder,
@@ -28,90 +44,91 @@ static string GetNullabilityAnnotation(NullabilityInfo target)
         ? NullableAnnotationSyntaxString
         : string.Empty;
 
-    Type? byRefParameterType = null;
-
-    if (target.Type.IsByRef && options.AttributeProvider is ParameterInfo p) {
-      // retval/parameter modifiers
-      if (p.IsIn)
-        builder.Append("in ");
-      else if (p.IsOut)
-        builder.Append("out ");
-      else /*if (p.IsRetval)*/
-        builder.Append("ref ");
+    if (target.Type.IsByRef) {
+      var elementTypeNullabilityInfo = target.ElementType;
+
+      if (options.AttributeProvider is ParameterInfo p) {
+        // retval/parameter modifiers
+        if (p.IsIn)
+          builder.Append("in ");
+        else if (p.IsOut)
+          builder.Append("out ");
+        else /*if (p.IsRetval)*/
+          builder.Append("ref ");
+
+        // [.net6.0] Currently, NullabilityInfo.ElementType is always null if the type is ByRef.
+        // Uses the workaround implementation instead in that case.
+        // See https://github.com/dotnet/runtime/issues/72320
+        if (target.ElementType is null && p.ParameterType.HasElementType)
+          elementTypeNullabilityInfo = new NullabilityInfoContext().Create(new ByRefElementTypeParameterInfo(p)); // TODO: context
+      }
 
-      byRefParameterType = target.Type.GetElementTypeOrThrow();
+      if (elementTypeNullabilityInfo is not null) {
+        return FormatTypeNameWithNullabilityAnnotation(
+          elementTypeNullabilityInfo,
+          builder,
+          options
+        );
+      }
     }
 
-    if (target.ElementType is not null) {
+    if (target.Type.IsArray) {
       // arrays
-      return FormatTypeNameWithNullabilityAnnotation(target.ElementType, builder, options)
+      return FormatTypeNameWithNullabilityAnnotation(target.ElementType!, builder, options)
         .Append('[')
         .Append(',', target.Type.GetArrayRank() - 1)
         .Append(']')
         .Append(GetNullabilityAnnotation(target));
     }
 
-    if (target.Type.IsPointer || (target.Type.IsByRef && options.AttributeProvider is not ParameterInfo))
+    if (target.Type.IsPointer || target.Type.IsByRef)
+      // pointer types or ByRef types (exclude ParameterInfo)
       return builder.Append(FormatTypeNameCore(target.Type, options));
 
-    var targetType = byRefParameterType ?? target.Type;
-
-    if (IsValueTupleType(targetType)) {
-      if (byRefParameterType is not null)
-        // TODO: cannot get NullabilityInfo of generic type arguments from by-ref parameter type
-        return builder.Append(FormatTypeNameCore(targetType, options));
-
+    if (IsValueTupleType(target.Type)) {
       // special case for value tuples (ValueTuple<>)
       return FormatValueTupleType(target, builder, options)
         .Append(GetNullabilityAnnotation(target));
     }
 
+    var targetType = target.Type;
     var isGenericTypeClosedOrDefinition =
       targetType.IsGenericTypeDefinition ||
       targetType.IsConstructedGenericType ||
       (targetType.IsGenericType && targetType.ContainsGenericParameters);
-    string? nullabilityAnnotationForByRefParameter = null;
 
     if (Nullable.GetUnderlyingType(targetType) is Type nullableUnderlyingType) {
-      if (byRefParameterType is not null)
-        // note: if the by-ref parameter is Nullable<>, NullabilityState will not be Nullable
-        nullabilityAnnotationForByRefParameter = NullableAnnotationSyntaxString;
-
       // nullable value types (Nullable<>)
       if (IsValueTupleType(nullableUnderlyingType)) {
         // special case for nullable value tuples (Nullable<ValueTuple<>>)
         return FormatValueTupleType(target, builder, options)
-          .Append(GetNullabilityAnnotation(target))
-          .Append(nullabilityAnnotationForByRefParameter);
+          .Append(GetNullabilityAnnotation(target));
       }
       else if (nullableUnderlyingType.IsGenericType) {
         // case for nullable generic value types (Nullable<GenericValueType<>>)
         return FormatNullableGenericValueType(target, builder, options)
-          .Append(GetNullabilityAnnotation(target))
-          .Append(nullabilityAnnotationForByRefParameter);
+          .Append(GetNullabilityAnnotation(target));
       }
 
       targetType = nullableUnderlyingType;
     }
     else if (isGenericTypeClosedOrDefinition) {
       // other generic types
-      if (targetType == byRefParameterType) {
+      if (targetType.IsByRef) {
         // TODO: cannot get NullabilityInfo of generic type arguments from by-ref parameter type
         return builder.Append(FormatTypeNameCore(targetType, options));
       }
       else {
         return FormatClosedGenericTypeOrGenericTypeDefinition(target, builder, options)
-          .Append(GetNullabilityAnnotation(target))
-          .Append(nullabilityAnnotationForByRefParameter);
+          .Append(GetNullabilityAnnotation(target));
       }
     }
 
     if (options.TranslateLanguagePrimitiveType && IsLanguagePrimitiveType(targetType, out var n)) {
       // language primitive types
       return builder
         .Append(n)
-        .Append(GetNullabilityAnnotation(target))
-        .Append(nullabilityAnnotationForByRefParameter);
+        .Append(GetNullabilityAnnotation(target));
     }
 
     if (targetType.IsGenericParameter && targetType.HasGenericParameterNoConstraints())
@@ -127,8 +144,7 @@ static string GetNullabilityAnnotation(NullabilityInfo target)
 
     return builder
       .Append(GetTypeName(targetType, options))
-      .Append(GetNullabilityAnnotation(target))
-      .Append(nullabilityAnnotationForByRefParameter);
+      .Append(GetNullabilityAnnotation(target));
   }
 
   private static StringBuilder FormatClosedGenericTypeOrGenericTypeDefinition(

tests/Smdn.Reflection.ReverseGenerating/Smdn.Reflection.ReverseGenerating/Generator.MemberDeclaration.Parameters.NullabilityAnnotations.cs

@@ -142,12 +142,12 @@ class RefModifier {
     class GenericTypes {
       [MemberDeclarationTestCase($"public void {nameof(ValueTupleOfValueTypeAndRefType)}(out (int X, string Y) p) {{}}")] public void ValueTupleOfValueTypeAndRefType(out (int X, string Y) p) => throw null;
       [MemberDeclarationTestCase($"public void {nameof(ValueTupleOfNullableValueTypeAndRefType)}(out (int? X, string Y) p) {{}}")] public void ValueTupleOfNullableValueTypeAndRefType(out (int? X, string Y) p) => throw null;
-      [SkipTestCase("cannot get NullabilityInfo of generic type arguments from by-ref parameter type")][MemberDeclarationTestCase($"public void {nameof(ValueTupleOfValueTypeAndNullableRefType)}(out (int X, string? Y) p) {{}}")] public void ValueTupleOfValueTypeAndNullableRefType(out (int X, string? Y) p) => throw null;
+      [MemberDeclarationTestCase($"public void {nameof(ValueTupleOfValueTypeAndNullableRefType)}(out (int X, string? Y) p) {{}}")] public void ValueTupleOfValueTypeAndNullableRefType(out (int X, string? Y) p) => throw null;
 
       [MemberDeclarationTestCase($"public void {nameof(IEnumerableOfValueType)}(out IEnumerable<int> p) {{}}", ParameterWithNamespace = false)] public void IEnumerableOfValueType(out IEnumerable<int> p) => throw null;
       [MemberDeclarationTestCase($"public void {nameof(IEnumerableOfNullableValueType)}(out IEnumerable<int?> p) {{}}", ParameterWithNamespace = false)] public void IEnumerableOfNullableValueType(out IEnumerable<int?> p) => throw null;
       [MemberDeclarationTestCase($"public void {nameof(IEnumerableOfRefType)}(out IEnumerable<string> p) {{}}", ParameterWithNamespace = false)] public void IEnumerableOfRefType(out IEnumerable<string> p) => throw null;
-      [SkipTestCase("cannot get NullabilityInfo of generic type arguments from by-ref parameter type")][MemberDeclarationTestCase($"public void {nameof(IEnumerableOfNullableRefType)}(out IEnumerable<string?> p) {{}}", ParameterWithNamespace = false)] public void IEnumerableOfNullableRefType(out IEnumerable<string?> p) => throw null;
+      [MemberDeclarationTestCase($"public void {nameof(IEnumerableOfNullableRefType)}(out IEnumerable<string?> p) {{}}", ParameterWithNamespace = false)] public void IEnumerableOfNullableRefType(out IEnumerable<string?> p) => throw null;
     }
   }
 

tests/Smdn.Reflection.ReverseGenerating/Smdn.Reflection.ReverseGenerating/Generator.MemberDeclaration.ReturnParameters.NullabilityAnnotations.cs

@@ -89,12 +89,12 @@ class Ref {
       class GenericTypes {
         [MemberDeclarationTestCase($"public ref (int X, string Y) {nameof(ValueTupleOfValueTypeAndRefType)}() {{}}")] public ref (int X, string Y) ValueTupleOfValueTypeAndRefType() => throw null;
         [MemberDeclarationTestCase($"public ref (int? X, string Y) {nameof(ValueTupleOfNullableValueTypeAndRefType)}() {{}}")] public ref (int? X, string Y) ValueTupleOfNullableValueTypeAndRefType() => throw null;
-        [SkipTestCase("cannot get NullabilityInfo of generic type arguments from by-ref parameter type")][MemberDeclarationTestCase($"public ref (int X, string? Y) {nameof(ValueTupleOfValueTypeAndNullableRefType)}() {{}}")] public ref (int X, string? Y) ValueTupleOfValueTypeAndNullableRefType() => throw null;
+        [MemberDeclarationTestCase($"public ref (int X, string? Y) {nameof(ValueTupleOfValueTypeAndNullableRefType)}() {{}}")] public ref (int X, string? Y) ValueTupleOfValueTypeAndNullableRefType() => throw null;
 
         [MemberDeclarationTestCase($"public ref IEnumerable<int> {nameof(IEnumerableOfValueType)}() {{}}", MemberWithNamespace = false)] public ref IEnumerable<int> IEnumerableOfValueType() => throw null;
         [MemberDeclarationTestCase($"public ref IEnumerable<int?> {nameof(IEnumerableOfNullableValueType)}() {{}}", MemberWithNamespace = false)] public ref IEnumerable<int?> IEnumerableOfNullableValueType() => throw null;
         [MemberDeclarationTestCase($"public ref IEnumerable<string> {nameof(IEnumerableOfRefType)}() {{}}", MemberWithNamespace = false)] public ref IEnumerable<string> IEnumerableOfRefType() => throw null;
-        [SkipTestCase("cannot get NullabilityInfo of generic type arguments from by-ref parameter type")][MemberDeclarationTestCase($"public ref IEnumerable<string?> {nameof(IEnumerableOfNullableRefType)}() {{}}", MemberWithNamespace = false)] public ref IEnumerable<string?> IEnumerableOfNullableRefType() => throw null;
+        [MemberDeclarationTestCase($"public ref IEnumerable<string?> {nameof(IEnumerableOfNullableRefType)}() {{}}", MemberWithNamespace = false)] public ref IEnumerable<string?> IEnumerableOfNullableRefType() => throw null;
       }
     }
   }