Merge pull request #3527 from jjonescz/allows-ref-struct

dgrunwald · web-flow · commit 2ca6e22384ab · 2025-08-01T08:54:29.000+02:00
Support `allows ref struct` constraint
diff --git a/ICSharpCode.Decompiler.Tests/DisassemblerPrettyTestRunner.cs b/ICSharpCode.Decompiler.Tests/DisassemblerPrettyTestRunner.cs
@@ -52,6 +52,12 @@ public void AllFilesHaveTests()
 			}
 		}
 
+		[Test]
+		public async Task GenericConstraints()
+		{
+			await Run();
+		}
+
 		[Test]
 		public async Task SecurityDeclarations()
 		{
diff --git a/ICSharpCode.Decompiler.Tests/ICSharpCode.Decompiler.Tests.csproj b/ICSharpCode.Decompiler.Tests/ICSharpCode.Decompiler.Tests.csproj
@@ -91,6 +91,7 @@
     <None Include="TestCases\Correctness\StackTests.il" />
     <None Include="TestCases\Correctness\StackTypes.il" />
     <None Include="TestCases\Correctness\Uninit.vb" />
+    <None Include="TestCases\Disassembler\Pretty\GenericConstraints.il" />
     <None Include="TestCases\Disassembler\Pretty\InterfaceImplAttributes.il" />
     <None Include="TestCases\Disassembler\Pretty\SortMembers.expected.il" />
     <None Include="TestCases\Disassembler\Pretty\SortMembers.il" />
diff --git a/ICSharpCode.Decompiler.Tests/PrettyTestRunner.cs b/ICSharpCode.Decompiler.Tests/PrettyTestRunner.cs
@@ -792,7 +792,7 @@ async Task Run([CallerMemberName] string testName = null, AssemblerOptions asmOp
 			configureDecompiler?.Invoke(settings);
 			var decompiled = await Tester.DecompileCSharp(exeFile, settings).ConfigureAwait(false);
 
-			// 3. Compile
+			// 3. Compare
 			CodeAssert.FilesAreEqual(csFile, decompiled, Tester.GetPreprocessorSymbols(cscOptions).Append("EXPECTED_OUTPUT").ToArray());
 			Tester.RepeatOnIOError(() => File.Delete(decompiled));
 		}
diff --git a/ICSharpCode.Decompiler.Tests/TestCases/Disassembler/Pretty/GenericConstraints.il b/ICSharpCode.Decompiler.Tests/TestCases/Disassembler/Pretty/GenericConstraints.il
@@ -0,0 +1,45 @@
+.assembly extern mscorlib
+{
+	.publickeytoken = (
+		b7 7a 5c 56 19 34 e0 89
+	)
+	.ver 4:0:0:0
+}
+.assembly GenericConstraints
+{
+	.custom instance void [mscorlib]System.Reflection.AssemblyFileVersionAttribute::.ctor(string) = (
+		01 00 07 31 2e 30 2e 30 2e 30 00 00
+	)
+	.hash algorithm 0x00008004 // SHA1
+	.ver 1:0:0:0
+}
+
+.module GenericConstraints.dll
+.imagebase 0x10000000
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003 // WindowsCui
+.corflags 0x00000001 // ILOnly
+
+.class private auto ansi '<Module>'
+{
+} // end of class <Module>
+
+.class public auto ansi beforefieldinit TestType`1<byreflike T>
+	extends [mscorlib]System.Object
+{
+	// Methods
+	.method public hidebysig specialname rtspecialname
+		instance void .ctor () cil managed
+	{
+		// Method begins at RVA 0x2050
+		// Header size: 1
+		// Code size: 7 (0x7)
+		.maxstack 8
+
+		IL_0000: ldarg.0
+		IL_0001: call instance void [mscorlib]System.Object::.ctor()
+		IL_0006: ret
+	} // end of method TestType::.ctor
+
+} // end of class TestType
diff --git a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/Generics.cs b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/Generics.cs
@@ -293,6 +293,12 @@ public unsafe static int UnmanagedConstraint<T>() where T : unmanaged
 		}
 #endif
 
+#if NET90
+		public static void AllowsRefStruct<T>() where T : allows ref struct
+		{
+		}
+#endif
+
 		public static void Issue1959(int a, int b, int? c)
 		{
 			// This line requires parentheses around `a < b` to avoid a grammar ambiguity.
diff --git a/ICSharpCode.Decompiler/CSharp/Syntax/TypeSystemAstBuilder.cs b/ICSharpCode.Decompiler/CSharp/Syntax/TypeSystemAstBuilder.cs
@@ -2465,7 +2465,7 @@ internal TypeParameterDeclaration ConvertTypeParameter(ITypeParameter tp)
 
 		internal Constraint ConvertTypeParameterConstraint(ITypeParameter tp)
 		{
-			if (!tp.HasDefaultConstructorConstraint && !tp.HasReferenceTypeConstraint && !tp.HasValueTypeConstraint && tp.NullabilityConstraint != Nullability.NotNullable && tp.DirectBaseTypes.All(IsObjectOrValueType))
+			if (!tp.HasDefaultConstructorConstraint && !tp.HasReferenceTypeConstraint && !tp.HasValueTypeConstraint && !tp.AllowsRefLikeType && tp.NullabilityConstraint != Nullability.NotNullable && tp.DirectBaseTypes.All(IsObjectOrValueType))
 			{
 				return null;
 			}
@@ -2518,6 +2518,10 @@ internal Constraint ConvertTypeParameterConstraint(ITypeParameter tp)
 			{
 				c.BaseTypes.Add(new PrimitiveType("new"));
 			}
+			if (tp.AllowsRefLikeType)
+			{
+				c.BaseTypes.Add(new PrimitiveType("allows ref struct"));
+			}
 			return c;
 		}
 
diff --git a/ICSharpCode.Decompiler/Disassembler/ReflectionDisassembler.cs b/ICSharpCode.Decompiler/Disassembler/ReflectionDisassembler.cs
@@ -28,6 +28,7 @@
 using ICSharpCode.Decompiler.DebugInfo;
 using ICSharpCode.Decompiler.IL;
 using ICSharpCode.Decompiler.Metadata;
+using ICSharpCode.Decompiler.TypeSystem;
 
 namespace ICSharpCode.Decompiler.Disassembler
 {
@@ -1733,6 +1734,10 @@ void WriteTypeParameters(ITextOutput output, MetadataFile module, MetadataGeneri
 					{
 						output.Write("valuetype ");
 					}
+					if ((gp.Attributes & TypeUtils.AllowByRefLike) == TypeUtils.AllowByRefLike)
+					{
+						output.Write("byreflike ");
+					}
 					if ((gp.Attributes & GenericParameterAttributes.DefaultConstructorConstraint) == GenericParameterAttributes.DefaultConstructorConstraint)
 					{
 						output.Write(".ctor ");
diff --git a/ICSharpCode.Decompiler/TypeSystem/ITypeParameter.cs b/ICSharpCode.Decompiler/TypeSystem/ITypeParameter.cs
@@ -97,6 +97,11 @@ public interface ITypeParameter : IType, ISymbol
 		/// </summary>
 		bool HasUnmanagedConstraint { get; }
 
+		/// <summary>
+		/// <see langword="true"/> if the <c>allows ref struct</c> constraint is specified for the type parameter.
+		/// </summary>
+		bool AllowsRefLikeType { get; }
+
 		/// <summary>
 		/// Nullability of the reference type constraint. (e.g. "where T : class?").
 		/// 
diff --git a/ICSharpCode.Decompiler/TypeSystem/Implementation/AbstractTypeParameter.cs b/ICSharpCode.Decompiler/TypeSystem/Implementation/AbstractTypeParameter.cs
@@ -175,6 +175,7 @@ IReadOnlyCollection<IType> CalculateEffectiveInterfaceSet()
 		public abstract bool HasReferenceTypeConstraint { get; }
 		public abstract bool HasValueTypeConstraint { get; }
 		public abstract bool HasUnmanagedConstraint { get; }
+		public abstract bool AllowsRefLikeType { get; }
 		public abstract Nullability NullabilityConstraint { get; }
 
 		public TypeKind Kind {
diff --git a/ICSharpCode.Decompiler/TypeSystem/Implementation/DefaultTypeParameter.cs b/ICSharpCode.Decompiler/TypeSystem/Implementation/DefaultTypeParameter.cs
@@ -71,6 +71,7 @@ public DefaultTypeParameter(
 		public override bool HasReferenceTypeConstraint => hasReferenceTypeConstraint;
 		public override bool HasDefaultConstructorConstraint => hasDefaultConstructorConstraint;
 		public override bool HasUnmanagedConstraint => false;
+		public override bool AllowsRefLikeType => false;
 		public override Nullability NullabilityConstraint => nullabilityConstraint;
 
 		public override IReadOnlyList<TypeConstraint> TypeConstraints { get; }
diff --git a/ICSharpCode.Decompiler/TypeSystem/Implementation/DummyTypeParameter.cs b/ICSharpCode.Decompiler/TypeSystem/Implementation/DummyTypeParameter.cs
@@ -179,6 +179,7 @@ IReadOnlyCollection<IType> ITypeParameter.EffectiveInterfaceSet {
 		bool ITypeParameter.HasReferenceTypeConstraint => false;
 		bool ITypeParameter.HasValueTypeConstraint => false;
 		bool ITypeParameter.HasUnmanagedConstraint => false;
+		bool ITypeParameter.AllowsRefLikeType => false;
 		Nullability ITypeParameter.NullabilityConstraint => Nullability.Oblivious;
 
 		IReadOnlyList<TypeConstraint> ITypeParameter.TypeConstraints => EmptyList<TypeConstraint>.Instance;
diff --git a/ICSharpCode.Decompiler/TypeSystem/Implementation/MetadataTypeParameter.cs b/ICSharpCode.Decompiler/TypeSystem/Implementation/MetadataTypeParameter.cs
@@ -119,6 +119,7 @@ public override IEnumerable<IAttribute> GetAttributes()
 		public override bool HasDefaultConstructorConstraint => (attr & GenericParameterAttributes.DefaultConstructorConstraint) != 0;
 		public override bool HasReferenceTypeConstraint => (attr & GenericParameterAttributes.ReferenceTypeConstraint) != 0;
 		public override bool HasValueTypeConstraint => (attr & GenericParameterAttributes.NotNullableValueTypeConstraint) != 0;
+		public override bool AllowsRefLikeType => (attr & TypeUtils.AllowByRefLike) != 0;
 
 		public override bool HasUnmanagedConstraint {
 			get {
diff --git a/ICSharpCode.Decompiler/TypeSystem/Implementation/NullabilityAnnotatedType.cs b/ICSharpCode.Decompiler/TypeSystem/Implementation/NullabilityAnnotatedType.cs
@@ -115,6 +115,7 @@ internal NullabilityAnnotatedTypeParameter(ITypeParameter type, Nullability null
 		bool ITypeParameter.HasReferenceTypeConstraint => baseType.HasReferenceTypeConstraint;
 		bool ITypeParameter.HasValueTypeConstraint => baseType.HasValueTypeConstraint;
 		bool ITypeParameter.HasUnmanagedConstraint => baseType.HasUnmanagedConstraint;
+		bool ITypeParameter.AllowsRefLikeType => baseType.AllowsRefLikeType;
 		Nullability ITypeParameter.NullabilityConstraint => baseType.NullabilityConstraint;
 		IReadOnlyList<TypeConstraint> ITypeParameter.TypeConstraints => baseType.TypeConstraints;
 		SymbolKind ISymbol.SymbolKind => SymbolKind.TypeParameter;
diff --git a/ICSharpCode.Decompiler/TypeSystem/Implementation/SpecializedMethod.cs b/ICSharpCode.Decompiler/TypeSystem/Implementation/SpecializedMethod.cs
@@ -278,6 +278,7 @@ public override bool Equals(IType other)
 			public override bool HasReferenceTypeConstraint => baseTp.HasReferenceTypeConstraint;
 			public override bool HasDefaultConstructorConstraint => baseTp.HasDefaultConstructorConstraint;
 			public override bool HasUnmanagedConstraint => baseTp.HasUnmanagedConstraint;
+			public override bool AllowsRefLikeType => baseTp.AllowsRefLikeType;
 
 			public override Nullability NullabilityConstraint => baseTp.NullabilityConstraint;
 
diff --git a/ICSharpCode.Decompiler/TypeSystem/TypeUtils.cs b/ICSharpCode.Decompiler/TypeSystem/TypeUtils.cs
@@ -16,6 +16,8 @@
 // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 // DEALINGS IN THE SOFTWARE.
 
+using System.Reflection;
+
 using ICSharpCode.Decompiler.IL;
 using ICSharpCode.Decompiler.TypeSystem.Implementation;
 
@@ -25,6 +27,8 @@ public static class TypeUtils
 	{
 		public const int NativeIntSize = 6; // between 4 (Int32) and 8 (Int64)
 
+		public const GenericParameterAttributes AllowByRefLike = (GenericParameterAttributes)0x0020;
+
 		/// <summary>
 		/// Gets the size (in bytes) of the input type.
 		/// Returns <c>NativeIntSize</c> for pointer-sized types.

Original file line number	Diff line number	Diff line change
`@@ -52,6 +52,12 @@ public void AllFilesHaveTests()`
`52`	`52`	`}`
`53`	`53`	`}`
`54`	`54`
	`55`	`+ [Test]`
	`56`	`+ public async Task GenericConstraints()`
	`57`	`+ {`
	`58`	`+ await Run();`
	`59`	`+ }`
	`60`	`+`
`55`	`61`	`[Test]`
`56`	`62`	`public async Task SecurityDeclarations()`
`57`	`63`	`{`
Original file line number	Diff line number	Diff line change
`@@ -792,7 +792,7 @@ async Task Run([CallerMemberName] string testName = null, AssemblerOptions asmOp`
`792`	`792`	`configureDecompiler?.Invoke(settings);`
`793`	`793`	`var decompiled = await Tester.DecompileCSharp(exeFile, settings).ConfigureAwait(false);`
`794`	`794`
`795`		`- // 3. Compile`
	`795`	`+ // 3. Compare`
`796`	`796`	`CodeAssert.FilesAreEqual(csFile, decompiled, Tester.GetPreprocessorSymbols(cscOptions).Append("EXPECTED_OUTPUT").ToArray());`
`797`	`797`	`Tester.RepeatOnIOError(() => File.Delete(decompiled));`
`798`	`798`	`}`
Original file line number	Diff line number	Diff line change
`@@ -293,6 +293,12 @@ public unsafe static int UnmanagedConstraint<T>() where T : unmanaged`
`293`	`293`	`}`
`294`	`294`	`#endif`
`295`	`295`
	`296`	`+#if NET90`
	`297`	`+ public static void AllowsRefStruct<T>() where T : allows ref struct`
	`298`	`+ {`
	`299`	`+ }`
	`300`	`+#endif`
	`301`	`+`
`296`	`302`	`public static void Issue1959(int a, int b, int? c)`
`297`	`303`	`{`
`298`	`304`	// This line requires parentheses around `a < b` to avoid a grammar ambiguity.
Original file line number	Diff line number	Diff line change
`@@ -2465,7 +2465,7 @@ internal TypeParameterDeclaration ConvertTypeParameter(ITypeParameter tp)`
`2465`	`2465`
`2466`	`2466`	`internal Constraint ConvertTypeParameterConstraint(ITypeParameter tp)`
`2467`	`2467`	`{`
`2468`		`- if (!tp.HasDefaultConstructorConstraint && !tp.HasReferenceTypeConstraint && !tp.HasValueTypeConstraint && tp.NullabilityConstraint != Nullability.NotNullable && tp.DirectBaseTypes.All(IsObjectOrValueType))`
	`2468`	`+ if (!tp.HasDefaultConstructorConstraint && !tp.HasReferenceTypeConstraint && !tp.HasValueTypeConstraint && !tp.AllowsRefLikeType && tp.NullabilityConstraint != Nullability.NotNullable && tp.DirectBaseTypes.All(IsObjectOrValueType))`
`2469`	`2469`	`{`
`2470`	`2470`	`return null;`
`2471`	`2471`	`}`
`@@ -2518,6 +2518,10 @@ internal Constraint ConvertTypeParameterConstraint(ITypeParameter tp)`
`2518`	`2518`	`{`
`2519`	`2519`	`c.BaseTypes.Add(new PrimitiveType("new"));`
`2520`	`2520`	`}`
	`2521`	`+ if (tp.AllowsRefLikeType)`
	`2522`	`+ {`
	`2523`	`+ c.BaseTypes.Add(new PrimitiveType("allows ref struct"));`
	`2524`	`+ }`
`2521`	`2525`	`return c;`
`2522`	`2526`	`}`
`2523`	`2527`
Original file line number	Diff line number	Diff line change
`@@ -28,6 +28,7 @@`
`28`	`28`	`using ICSharpCode.Decompiler.DebugInfo;`
`29`	`29`	`using ICSharpCode.Decompiler.IL;`
`30`	`30`	`using ICSharpCode.Decompiler.Metadata;`
	`31`	`+using ICSharpCode.Decompiler.TypeSystem;`
`31`	`32`
`32`	`33`	`namespace ICSharpCode.Decompiler.Disassembler`
`33`	`34`	`{`
`@@ -1733,6 +1734,10 @@ void WriteTypeParameters(ITextOutput output, MetadataFile module, MetadataGeneri`
`1733`	`1734`	`{`
`1734`	`1735`	`output.Write("valuetype ");`
`1735`	`1736`	`}`
	`1737`	`+ if ((gp.Attributes & TypeUtils.AllowByRefLike) == TypeUtils.AllowByRefLike)`
	`1738`	`+ {`
	`1739`	`+ output.Write("byreflike ");`
	`1740`	`+ }`
`1736`	`1741`	`if ((gp.Attributes & GenericParameterAttributes.DefaultConstructorConstraint) == GenericParameterAttributes.DefaultConstructorConstraint)`
`1737`	`1742`	`{`
`1738`	`1743`	`output.Write(".ctor ");`