Add support for C# 14 user-defined compound assignment operators

ICSharpCode.Decompiler.Tests/CorrectnessTestRunner.cs

@@ -145,6 +145,12 @@ public void AllFilesHaveTests()
 			CompilerOptions.Optimize | CompilerOptions.UseRoslynLatest,
 		}, executesCompiledOutput: true);
 
+		static readonly CompilerOptions[] roslyn5OrNewerOptions = Tester.SupportedOnCurrentPlatform(new[]
+		{
+			CompilerOptions.UseRoslynLatest,
+			CompilerOptions.Optimize | CompilerOptions.UseRoslynLatest,
+		});
+
 		static readonly CompilerOptions[] roslyn2OrNewerOptions = Tester.SupportedOnCurrentPlatform(new[]
 		{
 			CompilerOptions.UseRoslyn2_10_0 | CompilerOptions.TargetNet40,
@@ -211,6 +217,18 @@ public async Task CompoundAssignment([ValueSource(nameof(defaultOptions))] Compi
 			await RunCS(options: options);
 		}
 
+		[Test]
+		public async Task UserDefinedCompoundAssignment([ValueSource(nameof(roslyn5OrNewerOptions))] CompilerOptions options)
+		{
+			await RunCS(options: options);
+		}
+
+		[Test]
+		public async Task UserDefinedCompoundAssignmentInheritance([ValueSource(nameof(roslyn5OrNewerOptions))] CompilerOptions options)
+		{
+			await RunCS(options: options);
+		}
+
 		[Test]
 		public async Task PropertiesAndEvents([ValueSource(nameof(defaultOptions))] CompilerOptions options)
 		{

ICSharpCode.Decompiler.Tests/ICSharpCode.Decompiler.Tests.csproj

@@ -209,6 +209,9 @@
     <None Include="TestCases\ILPretty\InstanceOperatorCall.il" />
     <Compile Remove="TestCases\ILPretty\EnumArithmeticOutOfRange.cs" />
     <None Include="TestCases\ILPretty\EnumArithmeticOutOfRange.cs" />
+    <Compile Remove="TestCases\ILPretty\CompoundAssignmentOperatorEdgeCases.cs" />
+    <None Include="TestCases\ILPretty\CompoundAssignmentOperatorEdgeCases.cs" />
+    <None Include="TestCases\ILPretty\CompoundAssignmentOperatorEdgeCases.il" />
     <Compile Remove="TestCases\ILPretty\EmptyBodies.cs" />
     <None Include="TestCases\ILPretty\EmptyBodies.cs" />
     <Compile Remove="TestCases\ILPretty\TruncatedAccessorBody.cs" />
@@ -280,6 +283,8 @@
     <None Include="TestCases\Ugly\NoNewOfT.Expected.cs" />
     <Compile Remove="TestCases\Ugly\NoPropertiesAndEvents.Expected.cs" />
     <None Include="TestCases\Ugly\NoPropertiesAndEvents.Expected.cs" />
+    <Compile Remove="TestCases\Ugly\NoUserDefinedCompoundAssignmentOperators.Expected.cs" />
+    <None Include="TestCases\Ugly\NoUserDefinedCompoundAssignmentOperators.Expected.cs" />
     <Compile Remove="TestCases\Ugly\NoUnsignedRightShift.Expected.cs" />
     <None Include="TestCases\Ugly\NoUnsignedRightShift.Expected.cs" />
     <!-- top-level statements: neither the input nor the expected output can be compiled

ICSharpCode.Decompiler.Tests/ILPrettyTestRunner.cs

@@ -345,6 +345,12 @@ public async Task InstanceOperatorCall()
 			await Run();
 		}
 
+		[Test]
+		public async Task CompoundAssignmentOperatorEdgeCases()
+		{
+			await Run();
+		}
+
 		[Test]
 		public async Task FSharpLoops_Debug()
 		{

ICSharpCode.Decompiler.Tests/Output/CSharpAmbienceTests.cs

@@ -59,7 +59,8 @@ ITypeDefinition GetDefinition(Type type)
 			return foundType;
 		}
 
-		const ConversionFlags ILSpyMainTreeViewTypeFlags = ShowTypeParameterList | PlaceReturnTypeAfterParameterList;
+		const ConversionFlags ILSpyMainTreeViewTypeFlags = ShowTypeParameterList | PlaceReturnTypeAfterParameterList
+			| SupportOperatorChecked | SupportUnsignedRightShift | SupportUserDefinedCompoundAssignmentOperators;
 		const ConversionFlags ILSpyMainTreeViewMemberFlags = ILSpyMainTreeViewTypeFlags | ShowParameterList | ShowReturnType | ShowParameterModifiers;
 
 		#region ITypeDefinition tests
@@ -311,6 +312,41 @@ public void ConstructorTests(ConversionFlags flags, string expectedOutput)
 			Assert.That(ambience.ConvertSymbol(prop), Is.EqualTo(expectedOutput));
 		}
 
+		const ConversionFlags TooltipFlags = All & ~(ShowBody | PlaceReturnTypeAfterParameterList);
+
+		[TestCase(StandardConversionFlags, "public void operator op_AdditionAssignment(int rhs);")]
+		[TestCase(StandardConversionFlags | SupportUserDefinedCompoundAssignmentOperators, "public void operator +=(int rhs);")]
+		[TestCase(ILSpyMainTreeViewMemberFlags, "operator +=(int) : void")]
+		[TestCase(TooltipFlags, "public void ICSharpCode.Decompiler.Tests.Output.CSharpAmbienceTests.Program.operator +=(int rhs)")]
+		public void CompoundAssignmentOperatorTests(ConversionFlags flags, string expectedOutput)
+		{
+			var op = compilation.FindType(typeof(CSharpAmbienceTests.Program))
+				.GetMethods(m => m.Name == "op_AdditionAssignment").Single();
+			ambience.ConversionFlags = flags;
+
+			Assert.That(ambience.ConvertSymbol(op), Is.EqualTo(expectedOutput));
+		}
+
+		[TestCase(ILSpyMainTreeViewMemberFlags, "operator checked +=(int) : void")]
+		public void CheckedCompoundAssignmentOperatorTests(ConversionFlags flags, string expectedOutput)
+		{
+			var op = compilation.FindType(typeof(CSharpAmbienceTests.Program))
+				.GetMethods(m => m.Name == "op_CheckedAdditionAssignment").Single();
+			ambience.ConversionFlags = flags;
+
+			Assert.That(ambience.ConvertSymbol(op), Is.EqualTo(expectedOutput));
+		}
+
+		[TestCase(ILSpyMainTreeViewMemberFlags, "operator ++() : void")]
+		public void InstanceIncrementOperatorTests(ConversionFlags flags, string expectedOutput)
+		{
+			var op = compilation.FindType(typeof(CSharpAmbienceTests.Program))
+				.GetMethods(m => m.Name == "op_IncrementAssignment").Single();
+			ambience.ConversionFlags = flags;
+
+			Assert.That(ambience.ConvertSymbol(op), Is.EqualTo(expectedOutput));
+		}
+
 		[TestCase(StandardConversionFlags, "~Program();")]
 		[TestCase(ILSpyMainTreeViewMemberFlags, "~Program()")]
 		public void DestructorTests(ConversionFlags flags, string expectedOutput)
@@ -441,6 +477,21 @@ public event EventHandler SomeEvent {
 				throw new NotImplementedException();
 			}
 
+			public void operator +=(int rhs)
+			{
+				throw new NotImplementedException();
+			}
+
+			public void operator checked +=(int rhs)
+			{
+				throw new NotImplementedException();
+			}
+
+			public void operator ++()
+			{
+				throw new NotImplementedException();
+			}
+
 			public static implicit operator Test(Program lhs)
 			{
 				throw new NotImplementedException();

ICSharpCode.Decompiler.Tests/PrettyTestRunner.cs

@@ -836,6 +836,12 @@ public async Task FirstClassSpanConversions([ValueSource(nameof(roslyn5OrNewerOp
 			await RunForLibrary(cscOptions: cscOptions);
 		}
 
+		[Test]
+		public async Task UserDefinedCompoundAssignment([ValueSource(nameof(roslyn5OrNewerOptions))] CompilerOptions cscOptions)
+		{
+			await RunForLibrary(cscOptions: cscOptions);
+		}
+
 		[Test]
 		public async Task ExpandParamsArgumentsDisabled([ValueSource(nameof(defaultOptions))] CompilerOptions cscOptions)
 		{