diff --git a/ICSharpCode.Decompiler.Tests/CorrectnessTestRunner.cs b/ICSharpCode.Decompiler.Tests/CorrectnessTestRunner.cs
index a00fc4425a..0e898a8f5c 100644
--- a/ICSharpCode.Decompiler.Tests/CorrectnessTestRunner.cs
+++ b/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)
 		{
diff --git a/ICSharpCode.Decompiler.Tests/ICSharpCode.Decompiler.Tests.csproj b/ICSharpCode.Decompiler.Tests/ICSharpCode.Decompiler.Tests.csproj
index 714454f75b..ca125f4bb2 100644
--- a/ICSharpCode.Decompiler.Tests/ICSharpCode.Decompiler.Tests.csproj
+++ b/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
diff --git a/ICSharpCode.Decompiler.Tests/ILPrettyTestRunner.cs b/ICSharpCode.Decompiler.Tests/ILPrettyTestRunner.cs
index 7e9f8df947..44e1d8e8a0 100644
--- a/ICSharpCode.Decompiler.Tests/ILPrettyTestRunner.cs
+++ b/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()
 		{
diff --git a/ICSharpCode.Decompiler.Tests/Output/CSharpAmbienceTests.cs b/ICSharpCode.Decompiler.Tests/Output/CSharpAmbienceTests.cs
index 1c7db3227f..f39402e68b 100644
--- a/ICSharpCode.Decompiler.Tests/Output/CSharpAmbienceTests.cs
+++ b/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();
diff --git a/ICSharpCode.Decompiler.Tests/PrettyTestRunner.cs b/ICSharpCode.Decompiler.Tests/PrettyTestRunner.cs
index bafa49605c..7e6c17a761 100644
--- a/ICSharpCode.Decompiler.Tests/PrettyTestRunner.cs
+++ b/ICSharpCode.Decompiler.Tests/PrettyTestRunner.cs
@@ -818,6 +818,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)
 		{
diff --git a/ICSharpCode.Decompiler.Tests/TestCases/Correctness/UserDefinedCompoundAssignment.cs b/ICSharpCode.Decompiler.Tests/TestCases/Correctness/UserDefinedCompoundAssignment.cs
new file mode 100644
index 0000000000..4dc943cc09
--- /dev/null
+++ b/ICSharpCode.Decompiler.Tests/TestCases/Correctness/UserDefinedCompoundAssignment.cs
@@ -0,0 +1,320 @@
+// Copyright (c) 2026 Siegfried Pammer
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy of this
+// software and associated documentation files (the "Software"), to deal in the Software
+// without restriction, including without limitation the rights to use, copy, modify, merge,
+// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons
+// to whom the Software is furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all copies or
+// substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
+// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE
+// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+// DEALINGS IN THE SOFTWARE.
+
+
+using System;
+using System.Collections.Generic;
+
+namespace ICSharpCode.Decompiler.Tests.TestCases.Correctness
+{
+	class UserDefinedCompoundAssignment
+	{
+		static void Main()
+		{
+			InstanceOperator();
+			InheritedOperator();
+			ShadowedOperator();
+			StaticOperatorStaysStatic();
+			StaticTypeSelectsTheOperator();
+			IncrementDependsOnWhetherTheResultIsUsed();
+			StructOperator();
+			GenericOperator();
+			ForeachTarget();
+			UsingTarget();
+			InParameterTarget(new Base { Value = 40 });
+			ReadonlyFieldTarget();
+		}
+
+		class Base
+		{
+			public int Value;
+
+			public void operator +=(int rhs)
+			{
+				Console.WriteLine("Base.op_AdditionAssignment({0})", rhs);
+				Value += rhs;
+			}
+
+			public void operator ++()
+			{
+				Console.WriteLine("Base.op_IncrementAssignment()");
+				Value++;
+			}
+		}
+
+		class Derived : Base
+		{
+		}
+
+		// Declares the same signature as Base, so "s += n" must bind here and not to Base.
+		class Shadowing : Base
+		{
+			public new void operator +=(int rhs)
+			{
+				Console.WriteLine("Shadowing.op_AdditionAssignment({0})", rhs);
+				Value += rhs * 100;
+			}
+		}
+
+		// Declaring both forms means "b = b + n" and "b += n" do different things: the static
+		// operator produces a new instance, the instance one mutates the receiver.
+		class Both
+		{
+			public int Value;
+
+			public static Both operator +(Both lhs, int rhs)
+			{
+				Console.WriteLine("Both.op_Addition({0})", rhs);
+				return new Both { Value = lhs.Value + rhs };
+			}
+
+			public void operator +=(int rhs)
+			{
+				Console.WriteLine("Both.op_AdditionAssignment({0})", rhs);
+				Value += rhs * 1000;
+			}
+
+			public static Both operator ++(Both x)
+			{
+				Console.WriteLine("Both.op_Increment()");
+				return new Both { Value = x.Value + 1 };
+			}
+
+			public void operator ++()
+			{
+				Console.WriteLine("Both.op_IncrementAssignment()");
+				Value += 1000;
+			}
+		}
+
+		// Only the derived type declares an instance operator. Which operator "x += y" binds to
+		// therefore depends on the declared type of x, not on the runtime type of the object.
+		class StaticBase
+		{
+			public int Value;
+
+			public static StaticBase operator +(StaticBase lhs, int rhs)
+			{
+				Console.WriteLine("StaticBase.op_Addition({0})", rhs);
+				return new StaticBase { Value = lhs.Value + rhs };
+			}
+		}
+
+		class InstanceDerived : StaticBase
+		{
+			public void operator +=(int rhs)
+			{
+				Console.WriteLine("InstanceDerived.op_AdditionAssignment({0})", rhs);
+				Value += rhs * 10;
+			}
+		}
+
+		struct Counter
+		{
+			public int Value;
+
+			public void operator +=(int rhs)
+			{
+				Console.WriteLine("Counter.op_AdditionAssignment({0})", rhs);
+				Value += rhs;
+			}
+		}
+
+		interface ICompound
+		{
+			void operator +=(int rhs);
+		}
+
+		class ViaInterface : ICompound
+		{
+			public int Value;
+
+			public void operator +=(int rhs)
+			{
+				Console.WriteLine("ViaInterface.op_AdditionAssignment({0})", rhs);
+				Value += rhs;
+			}
+		}
+
+		static void InstanceOperator()
+		{
+			Base b = new Base { Value = 1 };
+			b += 2;
+			b++;
+			Console.WriteLine("InstanceOperator: " + b.Value);
+		}
+
+		static void InheritedOperator()
+		{
+			Derived d = new Derived { Value = 1 };
+			d += 2;
+			d++;
+			Console.WriteLine("InheritedOperator: " + d.Value);
+		}
+
+		static void ShadowedOperator()
+		{
+			Shadowing s = new Shadowing { Value = 1 };
+			s += 2;
+			Console.WriteLine("ShadowedOperator: " + s.Value);
+		}
+
+		static void StaticOperatorStaysStatic()
+		{
+			Both b = new Both { Value = 1 };
+			Both original = b;
+			b = b + 2;
+			Console.WriteLine("StaticOperatorStaysStatic: {0} {1} {2}", b.Value, original.Value, ReferenceEquals(b, original));
+
+			b += 2;
+			Console.WriteLine("InstanceOperatorMutatesInPlace: " + b.Value);
+		}
+
+		static void StaticTypeSelectsTheOperator()
+		{
+			StaticBase asBase = new InstanceDerived { Value = 1 };
+			asBase += 2;
+			Console.WriteLine("AsBase: " + asBase.Value);
+
+			InstanceDerived asDerived = new InstanceDerived { Value = 1 };
+			asDerived += 4;
+			Console.WriteLine("AsDerived: " + asDerived.Value);
+		}
+
+		// A postfix increment whose result is used cannot call an operator that mutates in place,
+		// so it takes the static one even though an instance operator is declared. Discarding the
+		// result, or writing the prefix form, reaches the instance operator instead.
+		static void IncrementDependsOnWhetherTheResultIsUsed()
+		{
+			Both a = new Both { Value = 1 };
+			Both old = a++;
+			Console.WriteLine("PostfixResultUsed: {0} {1} {2}", a.Value, old.Value, ReferenceEquals(a, old));
+
+			Both b = new Both { Value = 1 };
+			b++;
+			Console.WriteLine("PostfixDiscarded: " + b.Value);
+
+			Both c = new Both { Value = 1 };
+			Both n = ++c;
+			Console.WriteLine("PrefixResultUsed: {0} {1} {2}", c.Value, n.Value, ReferenceEquals(c, n));
+		}
+
+		static void StructOperator()
+		{
+			Counter c = default(Counter);
+			c += 3;
+			c += 4;
+			Console.WriteLine("StructOperator: " + c.Value);
+		}
+
+		static void UseGeneric<T>(T x, int n) where T : ICompound
+		{
+			x += n;
+		}
+
+		static void GenericOperator()
+		{
+			ViaInterface v = new ViaInterface { Value = 1 };
+			UseGeneric(v, 5);
+			Console.WriteLine("GenericOperator: " + v.Value);
+		}
+
+		sealed class DisposableHolder : IDisposable
+		{
+			public int Value;
+
+			public void operator +=(int rhs)
+			{
+				Console.WriteLine("DisposableHolder.op_AdditionAssignment({0})", rhs);
+				Value += rhs;
+			}
+
+			public void Dispose()
+			{
+				Console.WriteLine("Dispose({0})", Value);
+			}
+		}
+
+		static readonly Base readonlyField = new Base { Value = 10 };
+		readonly Base readonlyInstanceField;
+
+		static UserDefinedCompoundAssignment()
+		{
+			// A readonly field is a variable inside the matching constructor, so the
+			// operator form is legal here and has to stay.
+			readonlyField += 1;
+		}
+
+		UserDefinedCompoundAssignment()
+		{
+			readonlyInstanceField = new Base { Value = 20 };
+			readonlyInstanceField += 2;
+		}
+
+		static void ForeachTarget()
+		{
+			// The iteration variable is read-only, so the operator can only be applied
+			// to a copy; the copy has to survive decompilation.
+			List<Base> list = new List<Base> { new Base(), new Base() };
+			foreach (Base b in list)
+			{
+				Base copy = b;
+				copy += 3;
+			}
+			foreach (Base b in list)
+			{
+				Console.WriteLine("ForeachTarget: {0}", b.Value);
+			}
+			Base[] array = { new Base { Value = 30 } };
+			foreach (Base b in array)
+			{
+				Base copy = b;
+				copy += 4;
+			}
+			Console.WriteLine("ForeachTargetArray: {0}", array[0].Value);
+		}
+
+		static void UsingTarget()
+		{
+			// Same for a using variable.
+			using (DisposableHolder d = new DisposableHolder())
+			{
+				DisposableHolder copy = d;
+				copy += 5;
+			}
+		}
+
+		static void InParameterTarget(in Base b)
+		{
+			// And for an "in" parameter.
+			Base copy = b;
+			copy += 6;
+			Console.WriteLine("InParameterTarget: {0}", b.Value);
+		}
+
+		static void ReadonlyFieldTarget()
+		{
+			// Outside the constructor the readonly field is not a variable, so the
+			// copy has to survive here as well.
+			Base copy = readonlyField;
+			copy += 7;
+			Console.WriteLine("ReadonlyFieldTarget: {0}", readonlyField.Value);
+			Console.WriteLine("ReadonlyInstanceField: {0}", new UserDefinedCompoundAssignment().readonlyInstanceField.Value);
+		}
+	}
+}
diff --git a/ICSharpCode.Decompiler.Tests/TestCases/Correctness/UserDefinedCompoundAssignmentInheritance.cs b/ICSharpCode.Decompiler.Tests/TestCases/Correctness/UserDefinedCompoundAssignmentInheritance.cs
new file mode 100644
index 0000000000..ae7239c0e0
--- /dev/null
+++ b/ICSharpCode.Decompiler.Tests/TestCases/Correctness/UserDefinedCompoundAssignmentInheritance.cs
@@ -0,0 +1,681 @@
+// Copyright (c) 2026 Siegfried Pammer
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy of this
+// software and associated documentation files (the "Software"), to deal in the Software
+// without restriction, including without limitation the rights to use, copy, modify, merge,
+// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons
+// to whom the Software is furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all copies or
+// substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
+// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE
+// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+// DEALINGS IN THE SOFTWARE.
+
+
+using System;
+
+namespace ICSharpCode.Decompiler.Tests.TestCases.Correctness
+{
+	// Every combination of where a static "operator +" and an instance "operator +=" are
+	// declared across a two-level hierarchy, used through both a base-typed and a
+	// derived-typed variable. The class name suffix says what each level declares:
+	// N nothing, S static only, I instance only, X both - so Base_IS declares an instance
+	// operator and its derived class declares a static one.
+	//
+	// Which operator runs depends on the declared type of the left operand, not on the
+	// runtime type, and an instance operator reachable from that type wins over any static
+	// one. "x = x + n" therefore has to survive decompilation as-is wherever both forms
+	// exist: folding it to "x += n" would call a different operator.
+	class UserDefinedCompoundAssignmentInheritance
+	{
+		static void Main()
+		{
+			Combo_NS();
+			Combo_NI();
+			Combo_NX();
+			Combo_SN();
+			Combo_SS();
+			Combo_SI();
+			Combo_SX();
+			Combo_IN();
+			Combo_IS();
+			Combo_II();
+			Combo_IX();
+			Combo_XN();
+			Combo_XS();
+			Combo_XI();
+			Combo_XX();
+			Combo_BaseStaticReturnsDerived();
+			Combo_InstanceSignatureDoesNotApply();
+			Combo_DerivedOverloadHidesBase();
+		}
+
+		static void Combo_NS()
+		{
+			Console.WriteLine("NS derived-typed +=:");
+			Derived_NS asDerived = new Derived_NS { Value = 1 };
+			asDerived += 4;
+			Console.WriteLine("  -> " + asDerived.Value);
+		}
+
+		static void Combo_NI()
+		{
+			Console.WriteLine("NI derived-typed +=:");
+			Derived_NI asDerived = new Derived_NI { Value = 1 };
+			asDerived += 4;
+			Console.WriteLine("  -> " + asDerived.Value);
+		}
+
+		static void Combo_NX()
+		{
+			Console.WriteLine("NX derived-typed +=:");
+			Derived_NX asDerived = new Derived_NX { Value = 1 };
+			asDerived += 4;
+			Console.WriteLine("  -> " + asDerived.Value);
+			Console.WriteLine("NX derived-typed x = x + n:");
+			Derived_NX sDerived = new Derived_NX { Value = 1 };
+			sDerived = sDerived + 4;
+			Console.WriteLine("  -> " + sDerived.Value);
+		}
+
+		static void Combo_SN()
+		{
+			Console.WriteLine("SN base-typed +=:");
+			Base_SN asBase = new Derived_SN { Value = 1 };
+			asBase += 2;
+			Console.WriteLine("  -> " + asBase.Value);
+		}
+
+		static void Combo_SS()
+		{
+			Console.WriteLine("SS base-typed +=:");
+			Base_SS asBase = new Derived_SS { Value = 1 };
+			asBase += 2;
+			Console.WriteLine("  -> " + asBase.Value);
+			Console.WriteLine("SS derived-typed +=:");
+			Derived_SS asDerived = new Derived_SS { Value = 1 };
+			asDerived += 4;
+			Console.WriteLine("  -> " + asDerived.Value);
+		}
+
+		static void Combo_SI()
+		{
+			Console.WriteLine("SI base-typed +=:");
+			Base_SI asBase = new Derived_SI { Value = 1 };
+			asBase += 2;
+			Console.WriteLine("  -> " + asBase.Value);
+			Console.WriteLine("SI derived-typed +=:");
+			Derived_SI asDerived = new Derived_SI { Value = 1 };
+			asDerived += 4;
+			Console.WriteLine("  -> " + asDerived.Value);
+		}
+
+		static void Combo_SX()
+		{
+			Console.WriteLine("SX base-typed +=:");
+			Base_SX asBase = new Derived_SX { Value = 1 };
+			asBase += 2;
+			Console.WriteLine("  -> " + asBase.Value);
+			Console.WriteLine("SX derived-typed +=:");
+			Derived_SX asDerived = new Derived_SX { Value = 1 };
+			asDerived += 4;
+			Console.WriteLine("  -> " + asDerived.Value);
+			Console.WriteLine("SX derived-typed x = x + n:");
+			Derived_SX sDerived = new Derived_SX { Value = 1 };
+			sDerived = sDerived + 4;
+			Console.WriteLine("  -> " + sDerived.Value);
+		}
+
+		// The static operator is declared on the base but returns the derived type, so
+		// "x = x + n" is expressible on a derived-typed variable. Binary "+" only ever
+		// considers static operators, but "x += n" would find the derived class's instance
+		// operator first, so the assignment has to stay spelled out.
+		static void Combo_BaseStaticReturnsDerived()
+		{
+			Console.WriteLine("base static returning derived, derived-typed x = x + n:");
+			Derived_SR asDerived = new Derived_SR { Value = 1 };
+			asDerived = asDerived + 4;
+			Console.WriteLine("  -> " + asDerived.Value);
+			Console.WriteLine("base static returning derived, array element x = x + n:");
+			Derived_SR[] arr = new Derived_SR[1] { new Derived_SR { Value = 1 } };
+			arr[0] = arr[0] + 4;
+			Console.WriteLine("  -> " + arr[0].Value);
+		}
+
+		// Overload resolution removes base-type candidates when an applicable candidate exists
+		// in a more derived type: on a derived-typed target even an int argument binds the
+		// derived operator taking long. The base-typed variable is what makes the int overload
+		// reachable, so it has to survive decompilation.
+		static void Combo_DerivedOverloadHidesBase()
+		{
+			Console.WriteLine("overload base-typed +=:");
+			Derived_Overload target = new Derived_Overload { Value = 1 };
+			Base_Overload asBase = target;
+			asBase += 2;
+			Console.WriteLine("  -> " + target.Value);
+			Console.WriteLine("overload derived-typed +=:");
+			Derived_Overload asDerived = new Derived_Overload { Value = 1 };
+			asDerived += 4;
+			Console.WriteLine("  -> " + asDerived.Value);
+		}
+
+		// The instance operator takes an int, so it is not a candidate for a long argument
+		// and "x += n" binds the static operator: the assignment can be folded.
+		static void Combo_InstanceSignatureDoesNotApply()
+		{
+			Console.WriteLine("instance operator not applicable, long argument:");
+			MixedSignature asLocal = new MixedSignature { Value = 1 };
+			asLocal += 4L;
+			Console.WriteLine("  -> " + asLocal.Value);
+			Console.WriteLine("instance operator applicable, int argument:");
+			MixedSignature asInt = new MixedSignature { Value = 1 };
+			asInt += 4;
+			Console.WriteLine("  -> " + asInt.Value);
+		}
+
+		static void Combo_IN()
+		{
+			Console.WriteLine("IN base-typed +=:");
+			Base_IN asBase = new Derived_IN { Value = 1 };
+			asBase += 2;
+			Console.WriteLine("  -> " + asBase.Value);
+			Console.WriteLine("IN derived-typed +=:");
+			Derived_IN asDerived = new Derived_IN { Value = 1 };
+			asDerived += 4;
+			Console.WriteLine("  -> " + asDerived.Value);
+		}
+
+		static void Combo_IS()
+		{
+			Console.WriteLine("IS base-typed +=:");
+			Base_IS asBase = new Derived_IS { Value = 1 };
+			asBase += 2;
+			Console.WriteLine("  -> " + asBase.Value);
+			Console.WriteLine("IS derived-typed +=:");
+			Derived_IS asDerived = new Derived_IS { Value = 1 };
+			asDerived += 4;
+			Console.WriteLine("  -> " + asDerived.Value);
+			Console.WriteLine("IS derived-typed x = x + n:");
+			Derived_IS sDerived = new Derived_IS { Value = 1 };
+			sDerived = sDerived + 4;
+			Console.WriteLine("  -> " + sDerived.Value);
+		}
+
+		static void Combo_II()
+		{
+			Console.WriteLine("II base-typed +=:");
+			Base_II asBase = new Derived_II { Value = 1 };
+			asBase += 2;
+			Console.WriteLine("  -> " + asBase.Value);
+			Console.WriteLine("II derived-typed +=:");
+			Derived_II asDerived = new Derived_II { Value = 1 };
+			asDerived += 4;
+			Console.WriteLine("  -> " + asDerived.Value);
+		}
+
+		static void Combo_IX()
+		{
+			Console.WriteLine("IX base-typed +=:");
+			Base_IX asBase = new Derived_IX { Value = 1 };
+			asBase += 2;
+			Console.WriteLine("  -> " + asBase.Value);
+			Console.WriteLine("IX derived-typed +=:");
+			Derived_IX asDerived = new Derived_IX { Value = 1 };
+			asDerived += 4;
+			Console.WriteLine("  -> " + asDerived.Value);
+			Console.WriteLine("IX derived-typed x = x + n:");
+			Derived_IX sDerived = new Derived_IX { Value = 1 };
+			sDerived = sDerived + 4;
+			Console.WriteLine("  -> " + sDerived.Value);
+		}
+
+		static void Combo_XN()
+		{
+			Console.WriteLine("XN base-typed +=:");
+			Base_XN asBase = new Derived_XN { Value = 1 };
+			asBase += 2;
+			Console.WriteLine("  -> " + asBase.Value);
+			Console.WriteLine("XN base-typed x = x + n:");
+			Base_XN sBase = new Derived_XN { Value = 1 };
+			sBase = sBase + 2;
+			Console.WriteLine("  -> " + sBase.Value);
+			Console.WriteLine("XN derived-typed +=:");
+			Derived_XN asDerived = new Derived_XN { Value = 1 };
+			asDerived += 4;
+			Console.WriteLine("  -> " + asDerived.Value);
+		}
+
+		static void Combo_XS()
+		{
+			Console.WriteLine("XS base-typed +=:");
+			Base_XS asBase = new Derived_XS { Value = 1 };
+			asBase += 2;
+			Console.WriteLine("  -> " + asBase.Value);
+			Console.WriteLine("XS base-typed x = x + n:");
+			Base_XS sBase = new Derived_XS { Value = 1 };
+			sBase = sBase + 2;
+			Console.WriteLine("  -> " + sBase.Value);
+			Console.WriteLine("XS derived-typed +=:");
+			Derived_XS asDerived = new Derived_XS { Value = 1 };
+			asDerived += 4;
+			Console.WriteLine("  -> " + asDerived.Value);
+			Console.WriteLine("XS derived-typed x = x + n:");
+			Derived_XS sDerived = new Derived_XS { Value = 1 };
+			sDerived = sDerived + 4;
+			Console.WriteLine("  -> " + sDerived.Value);
+		}
+
+		static void Combo_XI()
+		{
+			Console.WriteLine("XI base-typed +=:");
+			Base_XI asBase = new Derived_XI { Value = 1 };
+			asBase += 2;
+			Console.WriteLine("  -> " + asBase.Value);
+			Console.WriteLine("XI base-typed x = x + n:");
+			Base_XI sBase = new Derived_XI { Value = 1 };
+			sBase = sBase + 2;
+			Console.WriteLine("  -> " + sBase.Value);
+			Console.WriteLine("XI derived-typed +=:");
+			Derived_XI asDerived = new Derived_XI { Value = 1 };
+			asDerived += 4;
+			Console.WriteLine("  -> " + asDerived.Value);
+		}
+
+		static void Combo_XX()
+		{
+			Console.WriteLine("XX base-typed +=:");
+			Base_XX asBase = new Derived_XX { Value = 1 };
+			asBase += 2;
+			Console.WriteLine("  -> " + asBase.Value);
+			Console.WriteLine("XX base-typed x = x + n:");
+			Base_XX sBase = new Derived_XX { Value = 1 };
+			sBase = sBase + 2;
+			Console.WriteLine("  -> " + sBase.Value);
+			Console.WriteLine("XX derived-typed +=:");
+			Derived_XX asDerived = new Derived_XX { Value = 1 };
+			asDerived += 4;
+			Console.WriteLine("  -> " + asDerived.Value);
+			Console.WriteLine("XX derived-typed x = x + n:");
+			Derived_XX sDerived = new Derived_XX { Value = 1 };
+			sDerived = sDerived + 4;
+			Console.WriteLine("  -> " + sDerived.Value);
+		}
+
+		class Base_NS
+		{
+			public int Value;
+		}
+
+		class Derived_NS : Base_NS
+		{
+			public static Derived_NS operator +(Derived_NS lhs, int rhs)
+			{
+				Console.WriteLine("  Derived_NS.op_Addition({0})", rhs);
+				return new Derived_NS { Value = lhs.Value + rhs };
+			}
+		}
+
+		class Base_NI
+		{
+			public int Value;
+		}
+
+		class Derived_NI : Base_NI
+		{
+			public void operator +=(int rhs)
+			{
+				Console.WriteLine("  Derived_NI.op_AdditionAssignment({0})", rhs);
+				Value += rhs;
+			}
+		}
+
+		class Base_NX
+		{
+			public int Value;
+		}
+
+		class Derived_NX : Base_NX
+		{
+			public static Derived_NX operator +(Derived_NX lhs, int rhs)
+			{
+				Console.WriteLine("  Derived_NX.op_Addition({0})", rhs);
+				return new Derived_NX { Value = lhs.Value + rhs };
+			}
+
+			public void operator +=(int rhs)
+			{
+				Console.WriteLine("  Derived_NX.op_AdditionAssignment({0})", rhs);
+				Value += rhs;
+			}
+		}
+
+		class Base_SN
+		{
+			public int Value;
+
+			public static Base_SN operator +(Base_SN lhs, int rhs)
+			{
+				Console.WriteLine("  Base_SN.op_Addition({0})", rhs);
+				return new Base_SN { Value = lhs.Value + rhs };
+			}
+		}
+
+		class Derived_SN : Base_SN
+		{
+		}
+
+		class Base_SS
+		{
+			public int Value;
+
+			public static Base_SS operator +(Base_SS lhs, int rhs)
+			{
+				Console.WriteLine("  Base_SS.op_Addition({0})", rhs);
+				return new Base_SS { Value = lhs.Value + rhs };
+			}
+		}
+
+		class Derived_SS : Base_SS
+		{
+			public static Derived_SS operator +(Derived_SS lhs, int rhs)
+			{
+				Console.WriteLine("  Derived_SS.op_Addition({0})", rhs);
+				return new Derived_SS { Value = lhs.Value + rhs };
+			}
+		}
+
+		class Base_SI
+		{
+			public int Value;
+
+			public static Base_SI operator +(Base_SI lhs, int rhs)
+			{
+				Console.WriteLine("  Base_SI.op_Addition({0})", rhs);
+				return new Base_SI { Value = lhs.Value + rhs };
+			}
+		}
+
+		class Derived_SI : Base_SI
+		{
+			public void operator +=(int rhs)
+			{
+				Console.WriteLine("  Derived_SI.op_AdditionAssignment({0})", rhs);
+				Value += rhs;
+			}
+		}
+
+		class Base_SX
+		{
+			public int Value;
+
+			public static Base_SX operator +(Base_SX lhs, int rhs)
+			{
+				Console.WriteLine("  Base_SX.op_Addition({0})", rhs);
+				return new Base_SX { Value = lhs.Value + rhs };
+			}
+		}
+
+		class Derived_SX : Base_SX
+		{
+			public static Derived_SX operator +(Derived_SX lhs, int rhs)
+			{
+				Console.WriteLine("  Derived_SX.op_Addition({0})", rhs);
+				return new Derived_SX { Value = lhs.Value + rhs };
+			}
+
+			public void operator +=(int rhs)
+			{
+				Console.WriteLine("  Derived_SX.op_AdditionAssignment({0})", rhs);
+				Value += rhs;
+			}
+		}
+
+		class Base_IN
+		{
+			public int Value;
+
+			public void operator +=(int rhs)
+			{
+				Console.WriteLine("  Base_IN.op_AdditionAssignment({0})", rhs);
+				Value += rhs;
+			}
+		}
+
+		class Derived_IN : Base_IN
+		{
+		}
+
+		class Base_IS
+		{
+			public int Value;
+
+			public void operator +=(int rhs)
+			{
+				Console.WriteLine("  Base_IS.op_AdditionAssignment({0})", rhs);
+				Value += rhs;
+			}
+		}
+
+		class Derived_IS : Base_IS
+		{
+			public static Derived_IS operator +(Derived_IS lhs, int rhs)
+			{
+				Console.WriteLine("  Derived_IS.op_Addition({0})", rhs);
+				return new Derived_IS { Value = lhs.Value + rhs };
+			}
+		}
+
+		class Base_II
+		{
+			public int Value;
+
+			public void operator +=(int rhs)
+			{
+				Console.WriteLine("  Base_II.op_AdditionAssignment({0})", rhs);
+				Value += rhs;
+			}
+		}
+
+		class Derived_II : Base_II
+		{
+			public new void operator +=(int rhs)
+			{
+				Console.WriteLine("  Derived_II.op_AdditionAssignment({0})", rhs);
+				Value += rhs;
+			}
+		}
+
+		class Base_IX
+		{
+			public int Value;
+
+			public void operator +=(int rhs)
+			{
+				Console.WriteLine("  Base_IX.op_AdditionAssignment({0})", rhs);
+				Value += rhs;
+			}
+		}
+
+		class Derived_IX : Base_IX
+		{
+			public static Derived_IX operator +(Derived_IX lhs, int rhs)
+			{
+				Console.WriteLine("  Derived_IX.op_Addition({0})", rhs);
+				return new Derived_IX { Value = lhs.Value + rhs };
+			}
+
+			public new void operator +=(int rhs)
+			{
+				Console.WriteLine("  Derived_IX.op_AdditionAssignment({0})", rhs);
+				Value += rhs;
+			}
+		}
+
+		class Base_XN
+		{
+			public int Value;
+
+			public static Base_XN operator +(Base_XN lhs, int rhs)
+			{
+				Console.WriteLine("  Base_XN.op_Addition({0})", rhs);
+				return new Base_XN { Value = lhs.Value + rhs };
+			}
+
+			public void operator +=(int rhs)
+			{
+				Console.WriteLine("  Base_XN.op_AdditionAssignment({0})", rhs);
+				Value += rhs;
+			}
+		}
+
+		class Derived_XN : Base_XN
+		{
+		}
+
+		class Base_XS
+		{
+			public int Value;
+
+			public static Base_XS operator +(Base_XS lhs, int rhs)
+			{
+				Console.WriteLine("  Base_XS.op_Addition({0})", rhs);
+				return new Base_XS { Value = lhs.Value + rhs };
+			}
+
+			public void operator +=(int rhs)
+			{
+				Console.WriteLine("  Base_XS.op_AdditionAssignment({0})", rhs);
+				Value += rhs;
+			}
+		}
+
+		class Derived_XS : Base_XS
+		{
+			public static Derived_XS operator +(Derived_XS lhs, int rhs)
+			{
+				Console.WriteLine("  Derived_XS.op_Addition({0})", rhs);
+				return new Derived_XS { Value = lhs.Value + rhs };
+			}
+		}
+
+		class Base_XI
+		{
+			public int Value;
+
+			public static Base_XI operator +(Base_XI lhs, int rhs)
+			{
+				Console.WriteLine("  Base_XI.op_Addition({0})", rhs);
+				return new Base_XI { Value = lhs.Value + rhs };
+			}
+
+			public void operator +=(int rhs)
+			{
+				Console.WriteLine("  Base_XI.op_AdditionAssignment({0})", rhs);
+				Value += rhs;
+			}
+		}
+
+		class Derived_XI : Base_XI
+		{
+			public new void operator +=(int rhs)
+			{
+				Console.WriteLine("  Derived_XI.op_AdditionAssignment({0})", rhs);
+				Value += rhs;
+			}
+		}
+
+		class Base_XX
+		{
+			public int Value;
+
+			public static Base_XX operator +(Base_XX lhs, int rhs)
+			{
+				Console.WriteLine("  Base_XX.op_Addition({0})", rhs);
+				return new Base_XX { Value = lhs.Value + rhs };
+			}
+
+			public void operator +=(int rhs)
+			{
+				Console.WriteLine("  Base_XX.op_AdditionAssignment({0})", rhs);
+				Value += rhs;
+			}
+		}
+
+		class Derived_XX : Base_XX
+		{
+			public static Derived_XX operator +(Derived_XX lhs, int rhs)
+			{
+				Console.WriteLine("  Derived_XX.op_Addition({0})", rhs);
+				return new Derived_XX { Value = lhs.Value + rhs };
+			}
+
+			public new void operator +=(int rhs)
+			{
+				Console.WriteLine("  Derived_XX.op_AdditionAssignment({0})", rhs);
+				Value += rhs;
+			}
+		}
+
+		class Base_SR
+		{
+			public int Value;
+
+			public static Derived_SR operator +(Base_SR lhs, int rhs)
+			{
+				Console.WriteLine("  Base_SR.op_Addition({0})", rhs);
+				return new Derived_SR { Value = lhs.Value + rhs };
+			}
+		}
+
+		class Derived_SR : Base_SR
+		{
+			public void operator +=(int rhs)
+			{
+				Console.WriteLine("  Derived_SR.op_AdditionAssignment({0})", rhs);
+				Value += rhs * 100;
+			}
+		}
+
+		class MixedSignature
+		{
+			public int Value;
+
+			public static MixedSignature operator +(MixedSignature lhs, long rhs)
+			{
+				Console.WriteLine("  MixedSignature.op_Addition({0})", rhs);
+				return new MixedSignature { Value = lhs.Value + (int)rhs };
+			}
+
+			public void operator +=(int rhs)
+			{
+				Console.WriteLine("  MixedSignature.op_AdditionAssignment({0})", rhs);
+				Value += rhs * 100;
+			}
+		}
+
+		class Base_Overload
+		{
+			public int Value;
+
+			public void operator +=(int rhs)
+			{
+				Console.WriteLine("  Base_Overload.op_AdditionAssignment({0})", rhs);
+				Value += rhs;
+			}
+		}
+
+		class Derived_Overload : Base_Overload
+		{
+			public void operator +=(long rhs)
+			{
+				Console.WriteLine("  Derived_Overload.op_AdditionAssignment({0}L)", rhs);
+				Value += (int)rhs * 100;
+			}
+		}
+	}
+}
diff --git a/ICSharpCode.Decompiler.Tests/TestCases/ILPretty/CompoundAssignmentOperatorEdgeCases.cs b/ICSharpCode.Decompiler.Tests/TestCases/ILPretty/CompoundAssignmentOperatorEdgeCases.cs
new file mode 100644
index 0000000000..0e151ddd13
--- /dev/null
+++ b/ICSharpCode.Decompiler.Tests/TestCases/ILPretty/CompoundAssignmentOperatorEdgeCases.cs
@@ -0,0 +1,200 @@
+using System.Runtime.CompilerServices;
+
+public class BadArityTarget
+{
+	public int Value;
+
+	// C# 14 compound assignment operators take exactly one parameter and the instance
+	// increment operators none; any other arity stays a plain method.
+	[SpecialName]
+	public void op_AdditionAssignment(int a, int b)
+	{
+	}
+
+	[SpecialName]
+	public void op_SubtractionAssignment()
+	{
+	}
+
+	[SpecialName]
+	public void op_IncrementAssignment(int a)
+	{
+	}
+}
+public class BadParameterShapes
+{
+	// C# allows only value, "in" and "ref readonly" parameters on a compound assignment
+	// operator; ref and params stay plain methods.
+	[SpecialName]
+	public void op_SubtractionAssignment(ref int rhs)
+	{
+	}
+
+	[SpecialName]
+	public void op_MultiplicationAssignment(params int[] rhs)
+	{
+	}
+}
+public class CompoundTarget
+{
+	public int Value;
+
+	public void operator +=(int rhs)
+	{
+		Value += rhs;
+	}
+
+	// Not "operator -=": C# 14 only recognizes void-returning instance methods as compound
+	// assignment operators, so a value-returning one stays a plain method.
+	[SpecialName]
+	public CompoundTarget op_SubtractionAssignment(int rhs)
+	{
+		return this;
+	}
+
+	[SpecialName]
+	public static CompoundTarget op_MultiplicationAssignment(CompoundTarget lhs, int rhs)
+	{
+		return lhs;
+	}
+}
+public class CovariantBase
+{
+	public int Value;
+
+	public static CovariantDerived operator ++(CovariantBase x)
+	{
+		return (CovariantDerived)x;
+	}
+}
+public class CovariantDerived : CovariantBase
+{
+	public void operator ++()
+	{
+	}
+}
+public class DerivedCompoundTarget : CompoundTarget
+{
+	public void CallBaseOperator(int n)
+	{
+		// "this" cannot be the target of "x op= y", so the receiver keeps a copy of it;
+		// the copy binds the same inherited operator the IL calls.
+		DerivedCompoundTarget derivedCompoundTarget = this;
+		derivedCompoundTarget += n;
+	}
+}
+public class EdgeCases
+{
+	public static int Sink;
+
+	public static CompoundTarget GetTarget()
+	{
+		return new CompoundTarget();
+	}
+
+	public static void NonVariableReceiver(int n)
+	{
+		CompoundTarget target = GetTarget();
+		target += n;
+	}
+
+	public static void UnconstrainedGenericReceiver<T>(T x, int n) where T : IOther
+	{
+		ICompound compound = (ICompound)(object)x;
+		compound += n;
+	}
+
+	// Not "x += n": C# requires a user-defined operator to be public, so an operator that
+	// is not cannot be bound by the operator form and the call has to stay a call.
+	public static void InaccessibleOperator(InaccessibleOperatorTarget x, int n)
+	{
+		x.op_AdditionAssignment(n);
+	}
+
+	public static void MismatchedReceiverType(object o, int n)
+	{
+		((CompoundTarget)o).op_AdditionAssignment(n);
+	}
+
+	// Not "x++": the type also declares the C# 14 instance "operator ++()", which "x++" binds
+	// in preference to the static one this call names.
+	public static ShadowTarget ShadowedIncrement(ShadowTarget x)
+	{
+		return ShadowTarget.op_Increment(x);
+	}
+
+	public static void CallNonCSharpOperators(CompoundTarget t, int n)
+	{
+		t.op_SubtractionAssignment(n);
+		CompoundTarget.op_MultiplicationAssignment(t, n);
+	}
+
+	// Not "++x": the static operator's covariant return lets the result be stored in a
+	// derived-typed local, and on that type "++x" would bind the instance operator.
+	public static CovariantDerived CovariantIncrement(CovariantDerived d)
+	{
+		CovariantDerived covariantDerived = CovariantBase.op_Increment(d);
+		Sink = covariantDerived.Value;
+		return covariantDerived;
+	}
+
+	// Not "x += n": the "in" overload is what the IL calls, but "x += n" binds the by-value
+	// overload, so the call has to stay a call.
+	public static void CallInOverload(InOverloads x, int n)
+	{
+		int rhs = n;
+		x.op_AdditionAssignment(in rhs);
+	}
+}
+public interface ICompound
+{
+	void operator +=(int rhs);
+}
+public class InaccessibleOperatorTarget
+{
+	public int Value;
+
+	// Not "operator +=": a non-public operator is not declarable as one in C#.
+	private void op_AdditionAssignment(int rhs)
+	{
+		Value += rhs;
+	}
+}
+public class InOverloads
+{
+	public int Value;
+
+	public void operator +=(int rhs)
+	{
+	}
+
+	public void operator +=(in int rhs)
+	{
+	}
+}
+public interface IOther
+{
+	void M();
+}
+public class ShadowTarget
+{
+	public int Value;
+
+	public static ShadowTarget operator ++(ShadowTarget x)
+	{
+		return x;
+	}
+
+	public void operator ++()
+	{
+		Value++;
+	}
+}
+public static class StaticClassOps
+{
+	// a static class cannot contain operators
+	[SpecialName]
+	public void op_AdditionAssignment(int rhs)
+	{
+	}
+}
diff --git a/ICSharpCode.Decompiler.Tests/TestCases/ILPretty/CompoundAssignmentOperatorEdgeCases.il b/ICSharpCode.Decompiler.Tests/TestCases/ILPretty/CompoundAssignmentOperatorEdgeCases.il
new file mode 100644
index 0000000000..4a64bf785b
--- /dev/null
+++ b/ICSharpCode.Decompiler.Tests/TestCases/ILPretty/CompoundAssignmentOperatorEdgeCases.il
@@ -0,0 +1,456 @@
+// Metadata version: v4.0.30319
+.assembly extern System.Runtime
+{
+  .publickeytoken = (B0 3F 5F 7F 11 D5 0A 3A )                         // .?_....:
+  .ver 11:0:0:0
+}
+.assembly CompoundAssignmentOperatorEdgeCases
+{
+  .ver 1:0:0:0
+}
+.module CompoundAssignmentOperatorEdgeCases.dll
+.imagebase 0x10000000
+.file alignment 0x00000200
+.stackreserve 0x00100000
+.subsystem 0x0003       // WINDOWS_CUI
+.corflags 0x00000001    //  ILONLY
+
+.class public auto ansi beforefieldinit CompoundTarget
+       extends [System.Runtime]System.Object
+{
+  .field public int32 Value
+
+  // A C# 14 user-defined compound assignment operator.
+  .method public hidebysig specialname instance void
+          op_AdditionAssignment(int32 rhs) cil managed
+  {
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  ldarg.0
+    IL_0002:  ldfld      int32 CompoundTarget::Value
+    IL_0007:  ldarg.1
+    IL_0008:  add
+    IL_0009:  stfld      int32 CompoundTarget::Value
+    IL_000e:  ret
+  }
+
+  // C++/CLI emits value-returning instance operators; C# has no syntax for those.
+  .method public hidebysig specialname instance class CompoundTarget
+          op_SubtractionAssignment(int32 rhs) cil managed
+  {
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  ret
+  }
+
+  // F# mangles "static member (*=)" to a static, value-returning op_MultiplicationAssignment.
+  .method public hidebysig specialname static class CompoundTarget
+          op_MultiplicationAssignment(class CompoundTarget lhs,
+                                      int32 rhs) cil managed
+  {
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  ret
+  }
+
+  .method public hidebysig specialname rtspecialname
+          instance void  .ctor() cil managed
+  {
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  call       instance void [System.Runtime]System.Object::.ctor()
+    IL_0006:  ret
+  }
+}
+
+.class public auto ansi beforefieldinit InaccessibleOperatorTarget
+       extends [System.Runtime]System.Object
+{
+  .field public int32 Value
+
+  // C# requires a user-defined operator to be public, so no C# expression can bind to
+  // this one and it cannot be declared as an operator either.
+  .method private hidebysig specialname instance void
+          op_AdditionAssignment(int32 rhs) cil managed
+  {
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  ldarg.0
+    IL_0002:  ldfld      int32 InaccessibleOperatorTarget::Value
+    IL_0007:  ldarg.1
+    IL_0008:  add
+    IL_0009:  stfld      int32 InaccessibleOperatorTarget::Value
+    IL_000e:  ret
+  }
+
+  .method public hidebysig specialname rtspecialname
+          instance void  .ctor() cil managed
+  {
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  call       instance void [System.Runtime]System.Object::.ctor()
+    IL_0006:  ret
+  }
+}
+
+.class interface public abstract auto ansi beforefieldinit ICompound
+{
+  .method public hidebysig newslot specialname abstract virtual
+          instance void  op_AdditionAssignment(int32 rhs) cil managed
+  {
+  }
+}
+
+.class interface public abstract auto ansi beforefieldinit IOther
+{
+  .method public hidebysig newslot abstract virtual
+          instance void  M() cil managed
+  {
+  }
+}
+
+.class public auto ansi beforefieldinit DerivedCompoundTarget
+       extends CompoundTarget
+{
+  .method public hidebysig instance void  CallBaseOperator(int32 n) cil managed
+  {
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  ldarg.1
+    IL_0002:  call       instance void CompoundTarget::op_AdditionAssignment(int32)
+    IL_0007:  ret
+  }
+
+  .method public hidebysig specialname rtspecialname
+          instance void  .ctor() cil managed
+  {
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  call       instance void CompoundTarget::.ctor()
+    IL_0006:  ret
+  }
+}
+
+.class public auto ansi beforefieldinit ShadowTarget
+       extends [System.Runtime]System.Object
+{
+  .field public int32 Value
+
+  // A static increment operator on a type that also declares the C# 14 instance one.
+  .method public hidebysig specialname static class ShadowTarget
+          op_Increment(class ShadowTarget x) cil managed
+  {
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  ret
+  }
+
+  .method public hidebysig specialname instance void
+          op_IncrementAssignment() cil managed
+  {
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  ldarg.0
+    IL_0002:  ldfld      int32 ShadowTarget::Value
+    IL_0007:  ldc.i4.1
+    IL_0008:  add
+    IL_0009:  stfld      int32 ShadowTarget::Value
+    IL_000e:  ret
+  }
+
+  .method public hidebysig specialname rtspecialname
+          instance void  .ctor() cil managed
+  {
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  call       instance void [System.Runtime]System.Object::.ctor()
+    IL_0006:  ret
+  }
+}
+
+.class public auto ansi beforefieldinit EdgeCases
+       extends [System.Runtime]System.Object
+{
+  .field public static int32 Sink
+
+  .method public hidebysig static class CompoundTarget
+          GetTarget() cil managed
+  {
+    .maxstack  8
+    IL_0000:  newobj     instance void CompoundTarget::.ctor()
+    IL_0005:  ret
+  }
+
+  // The receiver is not a variable, so it has to be given one before it can become the
+  // target of "x += n".
+  .method public hidebysig static void  NonVariableReceiver(int32 n) cil managed
+  {
+    .maxstack  8
+    IL_0000:  call       class CompoundTarget EdgeCases::GetTarget()
+    IL_0005:  ldarg.0
+    IL_0006:  callvirt   instance void CompoundTarget::op_AdditionAssignment(int32)
+    IL_000b:  ret
+  }
+
+  // T is not constrained to ICompound, so the cast selects the operator and has to stay; it
+  // is the variable holding the cast value that becomes the assignment target.
+  .method public hidebysig static void  UnconstrainedGenericReceiver<(IOther) T>(!!T x,
+                                                                                 int32 n) cil managed
+  {
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  box        !!T
+    IL_0006:  castclass  ICompound
+    IL_000b:  ldarg.1
+    IL_000c:  callvirt   instance void ICompound::op_AdditionAssignment(int32)
+    IL_0011:  ret
+  }
+
+  // The operator is not public, so the call cannot become "x += n".
+  .method public hidebysig static void  InaccessibleOperator(class InaccessibleOperatorTarget x,
+                                                             int32 n) cil managed
+  {
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  ldarg.1
+    IL_0002:  callvirt   instance void InaccessibleOperatorTarget::op_AdditionAssignment(int32)
+    IL_0007:  ret
+  }
+
+  // The receiver's static type does not declare the operator, so overload resolution has no
+  // candidate to pick.
+  .method public hidebysig static void  MismatchedReceiverType(object o,
+                                                               int32 n) cil managed
+  {
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  ldarg.1
+    IL_0002:  callvirt   instance void CompoundTarget::op_AdditionAssignment(int32)
+    IL_0007:  ret
+  }
+
+  // "x++" would bind the instance operator, so the call to the static one has to stay a call.
+  .method public hidebysig static class ShadowTarget
+          ShadowedIncrement(class ShadowTarget x) cil managed
+  {
+    .maxstack  8
+    .locals init (class ShadowTarget V_0)
+    IL_0000:  ldarg.0
+    IL_0001:  call       class ShadowTarget ShadowTarget::op_Increment(class ShadowTarget)
+    IL_0006:  stloc.0
+    IL_0007:  ldloc.0
+    IL_0008:  ret
+  }
+
+  .method public hidebysig static void  CallNonCSharpOperators(class CompoundTarget t,
+                                                               int32 n) cil managed
+  {
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  ldarg.1
+    IL_0002:  callvirt   instance class CompoundTarget CompoundTarget::op_SubtractionAssignment(int32)
+    IL_0007:  pop
+    IL_0008:  ldarg.0
+    IL_0009:  ldarg.1
+    IL_000a:  call       class CompoundTarget CompoundTarget::op_MultiplicationAssignment(class CompoundTarget,
+                                                                                          int32)
+    IL_000f:  pop
+    IL_0010:  ret
+  }
+
+  // Not "++x": the static operator's covariant return lets the result be stored in a
+  // derived-typed local, and on that type "++x" would bind the instance operator.
+  .method public hidebysig static class CovariantDerived
+          CovariantIncrement(class CovariantDerived d) cil managed
+  {
+    .maxstack  8
+    .locals init (class CovariantDerived V_0)
+    IL_0000:  ldarg.0
+    IL_0001:  call       class CovariantDerived CovariantBase::op_Increment(class CovariantBase)
+    IL_0006:  stloc.0
+    IL_0007:  ldloc.0
+    IL_0008:  ldfld      int32 CovariantBase::Value
+    IL_000d:  stsfld     int32 EdgeCases::Sink
+    IL_0012:  ldloc.0
+    IL_0013:  ret
+  }
+
+  // Not "x += n": the "in" overload is what the IL calls, but "x += n" binds the by-value
+  // overload, so the call has to stay a call.
+  .method public hidebysig static void  CallInOverload(class InOverloads x, int32 n) cil managed
+  {
+    .maxstack  8
+    .locals init (int32 V_0)
+    IL_0000:  ldarg.1
+    IL_0001:  stloc.0
+    IL_0002:  ldarg.0
+    IL_0003:  ldloca.s   V_0
+    IL_0005:  callvirt   instance void InOverloads::op_AdditionAssignment(int32&)
+    IL_000a:  ret
+  }
+
+  .method public hidebysig specialname rtspecialname
+          instance void  .ctor() cil managed
+  {
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  call       instance void [System.Runtime]System.Object::.ctor()
+    IL_0006:  ret
+  }
+}
+
+.class public auto ansi beforefieldinit BadArityTarget
+       extends [System.Runtime]System.Object
+{
+  .field public int32 Value
+
+  // C# 14 compound assignment operators take exactly one parameter and the instance
+  // increment operators none; any other arity stays a plain method.
+  .method public hidebysig specialname instance void
+          op_AdditionAssignment(int32 a,
+                                int32 b) cil managed
+  {
+    .maxstack  8
+    IL_0000:  ret
+  }
+
+  .method public hidebysig specialname instance void
+          op_SubtractionAssignment() cil managed
+  {
+    .maxstack  8
+    IL_0000:  ret
+  }
+
+  .method public hidebysig specialname instance void
+          op_IncrementAssignment(int32 a) cil managed
+  {
+    .maxstack  8
+    IL_0000:  ret
+  }
+
+  .method public hidebysig specialname rtspecialname
+          instance void  .ctor() cil managed
+  {
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  call       instance void [System.Runtime]System.Object::.ctor()
+    IL_0006:  ret
+  }
+}
+
+.class public auto ansi beforefieldinit CovariantBase
+       extends [System.Runtime]System.Object
+{
+  .field public int32 Value
+
+  .method public hidebysig specialname static class CovariantDerived
+          op_Increment(class CovariantBase x) cil managed
+  {
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  castclass  CovariantDerived
+    IL_0006:  ret
+  }
+
+  .method public hidebysig specialname rtspecialname
+          instance void  .ctor() cil managed
+  {
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  call       instance void [System.Runtime]System.Object::.ctor()
+    IL_0006:  ret
+  }
+}
+
+.class public auto ansi beforefieldinit CovariantDerived
+       extends CovariantBase
+{
+  .method public hidebysig specialname instance void
+          op_IncrementAssignment() cil managed
+  {
+    .maxstack  8
+    IL_0000:  ret
+  }
+
+  .method public hidebysig specialname rtspecialname
+          instance void  .ctor() cil managed
+  {
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  call       instance void CovariantBase::.ctor()
+    IL_0006:  ret
+  }
+}
+
+.class public auto ansi beforefieldinit BadParameterShapes
+       extends [System.Runtime]System.Object
+{
+  // C# allows only value, "in" and "ref readonly" parameters on a compound assignment
+  // operator; ref and params stay plain methods.
+  .method public hidebysig specialname instance void
+          op_SubtractionAssignment(int32& rhs) cil managed
+  {
+    .maxstack 8
+    ret
+  }
+
+  .method public hidebysig specialname instance void
+          op_MultiplicationAssignment(int32[] rhs) cil managed
+  {
+    .param [1]
+    .custom instance void [System.Runtime]System.ParamArrayAttribute::.ctor() = ( 01 00 00 00 )
+    .maxstack 8
+    ret
+  }
+
+  .method public hidebysig specialname rtspecialname instance void .ctor() cil managed
+  {
+    .maxstack 8
+    ldarg.0
+    call instance void [System.Runtime]System.Object::.ctor()
+    ret
+  }
+}
+
+// a static class cannot contain operators
+.class public abstract auto ansi sealed beforefieldinit StaticClassOps
+       extends [System.Runtime]System.Object
+{
+  .method public hidebysig specialname instance void
+          op_AdditionAssignment(int32 rhs) cil managed
+  {
+    .maxstack 8
+    ret
+  }
+}
+
+.class public auto ansi beforefieldinit InOverloads
+       extends [System.Runtime]System.Object
+{
+  .field public int32 Value
+
+  .method public hidebysig specialname instance void
+          op_AdditionAssignment(int32 rhs) cil managed
+  {
+    .maxstack  8
+    IL_0000:  ret
+  }
+
+  .method public hidebysig specialname instance void
+          op_AdditionAssignment([in] int32& rhs) cil managed
+  {
+    .param [1]
+    .custom instance void [System.Runtime]System.Runtime.CompilerServices.IsReadOnlyAttribute::.ctor() = ( 01 00 00 00 )
+    .maxstack  8
+    IL_0000:  ret
+  }
+
+  .method public hidebysig specialname rtspecialname
+          instance void  .ctor() cil managed
+  {
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  call       instance void [System.Runtime]System.Object::.ctor()
+    IL_0006:  ret
+  }
+}
diff --git a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/UserDefinedCompoundAssignment.cs b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/UserDefinedCompoundAssignment.cs
new file mode 100644
index 0000000000..553169cd3b
--- /dev/null
+++ b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/UserDefinedCompoundAssignment.cs
@@ -0,0 +1,555 @@
+// Copyright (c) 2026 Siegfried Pammer
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy of this
+// software and associated documentation files (the "Software"), to deal in the Software
+// without restriction, including without limitation the rights to use, copy, modify, merge,
+// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons
+// to whom the Software is furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all copies or
+// substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
+// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE
+// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+// DEALINGS IN THE SOFTWARE.
+
+using System;
+using System.Collections.Generic;
+
+namespace ICSharpCode.Decompiler.Tests.TestCases.Pretty
+{
+	internal class UserDefinedCompoundAssignment
+	{
+		public class CompoundClass
+		{
+			public int Value;
+
+			public void operator +=(int rhs)
+			{
+				Value += rhs;
+			}
+
+			public void operator checked +=(int rhs)
+			{
+				checked
+				{
+					Value += rhs;
+				}
+			}
+
+			public void operator -=(int rhs)
+			{
+				Value -= rhs;
+			}
+
+			public void operator checked -=(int rhs)
+			{
+				checked
+				{
+					Value -= rhs;
+				}
+			}
+
+			public void operator *=(int rhs)
+			{
+				Value *= rhs;
+			}
+
+			public void operator checked *=(int rhs)
+			{
+				checked
+				{
+					Value *= rhs;
+				}
+			}
+
+			public void operator /=(int rhs)
+			{
+				Value /= rhs;
+			}
+
+			public void operator checked /=(int rhs)
+			{
+				Value /= rhs;
+			}
+
+			public void operator %=(int rhs)
+			{
+				Value %= rhs;
+			}
+
+			public void operator &=(int rhs)
+			{
+				Value &= rhs;
+			}
+
+			public void operator |=(int rhs)
+			{
+				Value |= rhs;
+			}
+
+			public void operator ^=(int rhs)
+			{
+				Value ^= rhs;
+			}
+
+			public void operator <<=(int rhs)
+			{
+				Value <<= rhs;
+			}
+
+			public void operator >>=(int rhs)
+			{
+				Value >>= rhs;
+			}
+
+			public void operator >>>=(int rhs)
+			{
+				Value >>>= rhs;
+			}
+
+			public void operator ++()
+			{
+				Value++;
+			}
+
+			public void operator checked ++()
+			{
+				checked
+				{
+					Value++;
+				}
+			}
+
+			public void operator --()
+			{
+				Value--;
+			}
+
+			public void operator checked --()
+			{
+				checked
+				{
+					Value--;
+				}
+			}
+
+			public virtual void operator +=(long rhs)
+			{
+				Value += (int)rhs;
+			}
+
+			// "this" is not an assignable variable in a class, so the copy is what makes the
+			// operator form legal; it has to survive decompilation.
+			public void AddViaThisCopy(int n)
+			{
+				CompoundClass compoundClass = this;
+				compoundClass += n;
+			}
+
+			public void IncrementViaThisCopy()
+			{
+				CompoundClass compoundClass = this;
+				compoundClass++;
+			}
+		}
+
+		public struct CompoundStruct
+		{
+			public int Value;
+
+			public void operator +=(int rhs)
+			{
+				Value += rhs;
+			}
+
+			public readonly void operator -=(int rhs)
+			{
+				Console.WriteLine(Value - rhs);
+			}
+
+			public void operator ++()
+			{
+				Value++;
+			}
+
+			public void AddViaThis()
+			{
+				this += 10;
+			}
+		}
+
+		public class DerivedCompoundClass : CompoundClass
+		{
+		}
+
+		public class OverridingCompoundClass : CompoundClass
+		{
+			public override void operator +=(long rhs)
+			{
+				Value += (int)(rhs * 2);
+			}
+		}
+
+		public class ShadowingCompoundClass : CompoundClass
+		{
+			public new void operator +=(int rhs)
+			{
+				Value += rhs * 2;
+			}
+		}
+
+		public sealed class DisposableCompound : IDisposable
+		{
+			public int Value;
+
+			public void operator +=(int rhs)
+			{
+				Value += rhs;
+			}
+
+			public void Dispose()
+			{
+			}
+		}
+
+		public class ReadonlyFieldHolder
+		{
+			public static readonly CompoundClass Shared;
+
+			private readonly CompoundClass instance = new CompoundClass();
+
+			static ReadonlyFieldHolder()
+			{
+				Shared = new CompoundClass();
+				// A readonly field is a variable inside the matching constructor, so the
+				// operator form stays legal here.
+				Shared += 1;
+			}
+
+			public ReadonlyFieldHolder()
+			{
+				instance += 2;
+			}
+		}
+
+		// A value-type element makes csc address the storage once with ldelema, which is a
+		// different shape again from the reference-type case.
+		public struct StaticOnlyStruct
+		{
+			public int Value;
+
+			public static StaticOnlyStruct operator +(StaticOnlyStruct lhs, int rhs)
+			{
+				return new StaticOnlyStruct {
+					Value = lhs.Value + rhs
+				};
+			}
+		}
+
+		// No instance operator, so "x += n" reaches the static one and csc emits the compound
+		// assignment shape rather than a load and a store.
+		public class StaticOnlyOperators
+		{
+			public int Value;
+
+			public static StaticOnlyOperators operator +(StaticOnlyOperators lhs, int rhs)
+			{
+				return new StaticOnlyOperators {
+					Value = lhs.Value + rhs
+				};
+			}
+
+			public static StaticOnlyOperators operator ++(StaticOnlyOperators x)
+			{
+				return new StaticOnlyOperators {
+					Value = x.Value + 1
+				};
+			}
+		}
+
+		public class BothOperators
+		{
+			public int Value;
+
+			public static BothOperators operator +(BothOperators lhs, int rhs)
+			{
+				return new BothOperators {
+					Value = lhs.Value + rhs
+				};
+			}
+
+			public void operator +=(int rhs)
+			{
+				Value += rhs;
+			}
+
+			public static BothOperators operator ++(BothOperators x)
+			{
+				return new BothOperators {
+					Value = x.Value + 1
+				};
+			}
+
+			public void operator ++()
+			{
+				Value++;
+			}
+		}
+
+		public class MixedSignatureOperators
+		{
+			public int Value;
+
+			public static MixedSignatureOperators operator +(MixedSignatureOperators lhs, long rhs)
+			{
+				return new MixedSignatureOperators {
+					Value = lhs.Value + (int)rhs
+				};
+			}
+
+			public void operator +=(int rhs)
+			{
+				Value += rhs;
+			}
+		}
+
+		public interface ICompound<T>
+		{
+			void operator +=(T rhs);
+			void operator ++();
+		}
+
+		public class ExplicitCompound : ICompound<int>
+		{
+			public int Value;
+
+			void ICompound<int>.operator +=(int rhs)
+			{
+				Value += rhs;
+			}
+
+			void ICompound<int>.operator ++()
+			{
+				Value++;
+			}
+		}
+
+		private static CompoundClass staticField = new CompoundClass();
+
+		private CompoundClass instanceField = new CompoundClass();
+
+		private BothOperators bothField = new BothOperators();
+
+		private BothOperators[] bothArray = new BothOperators[4];
+
+		private static CompoundClass refReturnTarget = new CompoundClass();
+
+		private static CompoundStruct refReturnStructTarget;
+
+		public BothOperators BothProperty { get; set; }
+
+		public BothOperators this[int index] {
+			get {
+				return bothArray[index];
+			}
+			set {
+				bothArray[index] = value;
+			}
+		}
+
+		public static void UseClass(CompoundClass c, int n)
+		{
+			c += n;
+			c += 1;
+			c -= n;
+			c *= n;
+			c /= n;
+			c %= n;
+			c &= n;
+			c |= n;
+			c ^= n;
+			c <<= n;
+			c >>= n;
+			c >>>= n;
+			c += 2L;
+			c++;
+			c--;
+			checked
+			{
+				c += n;
+				c -= n;
+				c *= n;
+				c /= n;
+				c++;
+				c--;
+			}
+		}
+
+		public static void UseStruct(CompoundStruct s, int n)
+		{
+			s += n;
+			s -= n;
+			s++;
+		}
+
+		public static void UseOtherTargets(CompoundClass[] arr, ref CompoundClass rc, ref CompoundStruct rs, UserDefinedCompoundAssignment inst, int n)
+		{
+			staticField += n;
+			inst.instanceField += n;
+			arr[0] += n;
+			rc += n;
+			rs += n;
+			rs++;
+		}
+
+		public static void UseGeneric<T>(T x, int n) where T : ICompound<int>
+		{
+			x += n;
+			x++;
+		}
+
+		public static void UseInheritedOperator(DerivedCompoundClass d, int n)
+		{
+			d += n;
+			d++;
+		}
+
+		public static void UseShadowedOperator(ShadowingCompoundClass s, int n)
+		{
+			s += n;
+		}
+
+		public static void UseOverriddenOperator(OverridingCompoundClass o, long n)
+		{
+			o += n;
+		}
+
+		public static BothOperators UsePostfixIncrementResultUsed(BothOperators b)
+		{
+			return b++;
+		}
+
+		public static BothOperators UseStaticOperator(BothOperators b, int n)
+		{
+			// The IL calls the static operator, so the decompiled code has to keep calling it:
+			// "b += n" and "b++" would bind to the instance operators instead.
+			b = b + n;
+			b = b + 1;
+			return b;
+		}
+
+		public static void UseCompoundAssignmentOnArrayElement(StaticOnlyOperators[] arr, int n)
+		{
+			arr[0] += n;
+			arr[0]++;
+		}
+
+		public static void UseCompoundAssignmentOnStructArrayElement(StaticOnlyStruct[] arr, int n)
+		{
+			arr[0] += n;
+		}
+
+		public static void UseStaticOperatorOnArrayElement(BothOperators[] arr, int n)
+		{
+			// The element type declares an instance operator too, so the static call has to stay
+			// spelled out; array elements take a separate path through the decompiler to locals.
+			arr[0] = arr[0] + n;
+			arr[0] = arr[0] + 1;
+		}
+
+		public static void UseStaticOperatorOnField(UserDefinedCompoundAssignment inst, int n)
+		{
+			inst.bothField = inst.bothField + n;
+		}
+
+		public static void UseBaseTypedLocalOfShadowingClass(ShadowingCompoundClass s, int n)
+		{
+			// The local is what makes "c += n" bind the base operator rather than the shadowing
+			// one, so it has to survive even where the compiler optimized it away.
+			CompoundClass compoundClass = s;
+			compoundClass += n;
+		}
+
+		public static void UseStaticOperatorOnPropertyAndIndexer(UserDefinedCompoundAssignment inst, int n)
+		{
+			// A property and an indexer are not variables, so the instance operator is never a
+			// candidate for them: "x += n" binds the static operator, which is the one the IL calls.
+			inst.BothProperty += n;
+			inst[0] += n;
+		}
+
+		public static void UseStaticOperatorWhenInstanceDoesNotApply(MixedSignatureOperators m, MixedSignatureOperators[] arr, long n)
+		{
+			// The instance operator takes an int, so it is not a candidate for a long argument:
+			// "x += n" binds the static operator here, which is the one the IL calls.
+			m += n;
+			arr[0] += n;
+		}
+
+		public static void UseInstanceOperator(BothOperators b, int n)
+		{
+			b += n;
+			b++;
+		}
+
+		public static ref CompoundClass GetRefTarget()
+		{
+			return ref refReturnTarget;
+		}
+
+		public static ref CompoundStruct GetRefStructTarget()
+		{
+			return ref refReturnStructTarget;
+		}
+
+		public static void UseRefReturnTarget(int n)
+		{
+			// A ref-returning invocation is a variable, so the operator form binds here.
+			GetRefTarget() += n;
+			GetRefTarget()++;
+			GetRefStructTarget() += n;
+			GetRefStructTarget()++;
+		}
+
+		public unsafe static void UsePointerReceiver(CompoundStruct* p, int n)
+		{
+			// A pointer indirection is a variable, so the operator form binds here.
+			*p += n;
+			(*p)++;
+		}
+
+		public static void UseForeachVariableCopy(List<CompoundClass> list, int n)
+		{
+			// The iteration variable is read-only, so the operator is applied to a copy; the
+			// copy has to survive even where the compiler optimized it away.
+			foreach (CompoundClass item in list)
+			{
+				CompoundClass compoundClass = item;
+				compoundClass += n;
+			}
+		}
+
+		public static void UseUsingVariableCopy(int n)
+		{
+			// The using variable is read-only, so the operator is applied to a copy; the copy has
+			// to survive even where the compiler optimized it away.
+			using DisposableCompound disposableCompound = new DisposableCompound();
+			DisposableCompound disposableCompound2 = disposableCompound;
+			disposableCompound2 += n;
+		}
+
+		public static void UseExplicitInterfaceOperator(ExplicitCompound e, int n)
+		{
+			// The interface-typed variable is the only receiver that can bind an explicitly
+			// implemented operator, so the copy has to survive decompilation.
+			ICompound<int> compound = e;
+			compound += n;
+			ICompound<int> compound2 = e;
+			compound2++;
+		}
+	}
+}
diff --git a/ICSharpCode.Decompiler.Tests/TestCases/Ugly/NoUserDefinedCompoundAssignmentOperators.Expected.cs b/ICSharpCode.Decompiler.Tests/TestCases/Ugly/NoUserDefinedCompoundAssignmentOperators.Expected.cs
new file mode 100644
index 0000000000..5947bdf26c
--- /dev/null
+++ b/ICSharpCode.Decompiler.Tests/TestCases/Ugly/NoUserDefinedCompoundAssignmentOperators.Expected.cs
@@ -0,0 +1,49 @@
+using System.Runtime.CompilerServices;
+
+namespace ICSharpCode.Decompiler.Tests.TestCases.Ugly;
+
+internal class NoUserDefinedCompoundAssignmentOperators
+{
+	public class Compound
+	{
+		public int Value;
+
+		[SpecialName]
+		[CompilerFeatureRequired("UserDefinedCompoundAssignmentOperators")]
+		public void op_AdditionAssignment(int rhs)
+		{
+			Value += rhs;
+		}
+
+		[SpecialName]
+		[CompilerFeatureRequired("UserDefinedCompoundAssignmentOperators")]
+		public void op_SubtractionAssignment(int rhs)
+		{
+			Value -= rhs;
+		}
+
+		[SpecialName]
+		[CompilerFeatureRequired("UserDefinedCompoundAssignmentOperators")]
+		public void op_CheckedSubtractionAssignment(int rhs)
+		{
+			checked
+			{
+				Value -= rhs;
+			}
+		}
+
+		[SpecialName]
+		[CompilerFeatureRequired("UserDefinedCompoundAssignmentOperators")]
+		public void op_IncrementAssignment()
+		{
+			Value++;
+		}
+	}
+
+	public static void Use(Compound c, int n)
+	{
+		c.op_AdditionAssignment(n);
+		c.op_CheckedSubtractionAssignment(n);
+		c.op_IncrementAssignment();
+	}
+}
diff --git a/ICSharpCode.Decompiler.Tests/TestCases/Ugly/NoUserDefinedCompoundAssignmentOperators.cs b/ICSharpCode.Decompiler.Tests/TestCases/Ugly/NoUserDefinedCompoundAssignmentOperators.cs
new file mode 100644
index 0000000000..2c60f20fd5
--- /dev/null
+++ b/ICSharpCode.Decompiler.Tests/TestCases/Ugly/NoUserDefinedCompoundAssignmentOperators.cs
@@ -0,0 +1,60 @@
+// Copyright (c) 2026 Siegfried Pammer
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy of this
+// software and associated documentation files (the "Software"), to deal in the Software
+// without restriction, including without limitation the rights to use, copy, modify, merge,
+// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons
+// to whom the Software is furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all copies or
+// substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
+// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE
+// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+// DEALINGS IN THE SOFTWARE.
+
+using System;
+
+namespace ICSharpCode.Decompiler.Tests.TestCases.Ugly
+{
+	internal class NoUserDefinedCompoundAssignmentOperators
+	{
+		public class Compound
+		{
+			public int Value;
+
+			public void operator +=(int rhs)
+			{
+				Value += rhs;
+			}
+
+			public void operator -=(int rhs)
+			{
+				Value -= rhs;
+			}
+
+			public void operator checked -=(int rhs)
+			{
+				Value = checked(Value - rhs);
+			}
+
+			public void operator ++()
+			{
+				Value++;
+			}
+		}
+
+		public static void Use(Compound c, int n)
+		{
+			c += n;
+			checked
+			{
+				c -= n;
+			}
+			c++;
+		}
+	}
+}
diff --git a/ICSharpCode.Decompiler.Tests/UglyTestRunner.cs b/ICSharpCode.Decompiler.Tests/UglyTestRunner.cs
index c898078432..ff2ca78481 100644
--- a/ICSharpCode.Decompiler.Tests/UglyTestRunner.cs
+++ b/ICSharpCode.Decompiler.Tests/UglyTestRunner.cs
@@ -136,6 +136,14 @@ public async Task NoFieldKeyword([ValueSource(nameof(roslynLatestOnlyOptions))]
 			});
 		}
 
+		[Test]
+		public async Task NoUserDefinedCompoundAssignmentOperators([ValueSource(nameof(roslynLatestOnlyOptions))] CompilerOptions cscOptions)
+		{
+			await RunForLibrary(cscOptions: cscOptions, decompilerSettings: new DecompilerSettings {
+				UserDefinedCompoundAssignmentOperators = false
+			});
+		}
+
 		[Test]
 		public async Task NoInitAccessors([ValueSource(nameof(initAccessorOptions))] CompilerOptions cscOptions)
 		{
diff --git a/ICSharpCode.Decompiler/CSharp/CSharpDecompiler.cs b/ICSharpCode.Decompiler/CSharp/CSharpDecompiler.cs
index ad511a4930..4527fc9faf 100644
--- a/ICSharpCode.Decompiler/CSharp/CSharpDecompiler.cs
+++ b/ICSharpCode.Decompiler/CSharp/CSharpDecompiler.cs
@@ -795,6 +795,7 @@ static TypeSystemAstBuilder CreateAstBuilder(DecompilerSettings settings)
 			typeSystemAstBuilder.SupportOperatorChecked = settings.CheckedOperators;
 			typeSystemAstBuilder.AlwaysUseGlobal = settings.AlwaysUseGlobal;
 			typeSystemAstBuilder.SupportExtensionDeclarations = settings.ExtensionMembers;
+			typeSystemAstBuilder.SupportUserDefinedCompoundAssignmentOperators = settings.UserDefinedCompoundAssignmentOperators;
 			return typeSystemAstBuilder;
 		}
 
@@ -1678,15 +1679,16 @@ bool HidesMemberOrTypeOfBaseType()
 								return true;
 							}
 						}
-						else if (entity.SymbolKind == SymbolKind.Method)
+						else if (entity.SymbolKind is SymbolKind.Method or SymbolKind.Operator)
 						{
 							// A method introduced in a class or struct hides all non-method base class members with the same name, and all
 							// base class methods with the same signature (method name and parameter count, modifiers, and types).
+							// Instance operators hide by those same rules.
 							if (baseType.GetMembers(m => m.SymbolKind != SymbolKind.Indexer
 													&& m.SymbolKind != SymbolKind.Constructor
 													&& m.SymbolKind != SymbolKind.Destructor
 													&& m.Name == entity.Name && lookup.IsAccessible(m, true))
-								.Any(m => m.SymbolKind != SymbolKind.Method ||
+								.Any(m => m.SymbolKind is not (SymbolKind.Method or SymbolKind.Operator) ||
 									(((IMethod)entity).TypeParameters.Count == ((IMethod)m).TypeParameters.Count
 										&& parameterListComparer.Equals(((IMethod)entity).Parameters, ((IMethod)m).Parameters))))
 							{
@@ -2193,8 +2195,11 @@ EntityDeclaration DoDecompile(IMethod method, DecompileRun decompileRun, ITypeRe
 					methodDecl.Modifiers |= Modifiers.Extern;
 				}
 				// Accessors qualify only when they are emitted as ordinary methods (parameterized
-				// properties); an Accessor node cannot carry the 'new' modifier.
-				if ((method.SymbolKind == SymbolKind.Method || (method.SymbolKind == SymbolKind.Accessor && methodDecl is MethodDeclaration))
+				// properties); an Accessor node cannot carry the 'new' modifier. Instance operators
+				// hide by signature like ordinary methods do; static ones cannot carry 'new' at all.
+				if ((method.SymbolKind == SymbolKind.Method
+						|| (method.SymbolKind == SymbolKind.Operator && !method.IsStatic)
+						|| (method.SymbolKind == SymbolKind.Accessor && methodDecl is MethodDeclaration))
 					&& !method.IsExplicitInterfaceImplementation
 					&& methodDefinition.HasFlag(System.Reflection.MethodAttributes.Virtual) == methodDefinition.HasFlag(System.Reflection.MethodAttributes.NewSlot))
 				{
@@ -2220,6 +2225,10 @@ EntityDeclaration DoDecompile(IMethod method, DecompileRun decompileRun, ITypeRe
 				{
 					RemoveObsoleteAttribute(methodDecl, "Constructors of types with required members are not supported in this version of your compiler.");
 				}
+				if (methodDecl is OperatorDeclaration operatorDecl && OperatorDeclaration.IsCompoundAssignment(operatorDecl.OperatorType))
+				{
+					RemoveCompilerFeatureRequiredAttribute(methodDecl, "UserDefinedCompoundAssignmentOperators");
+				}
 				return methodDecl;
 
 				bool IsTypeHierarchyKnown(IType type)
diff --git a/ICSharpCode.Decompiler/CSharp/CallBuilder.cs b/ICSharpCode.Decompiler/CSharp/CallBuilder.cs
index 60dfe15098..365e387365 100644
--- a/ICSharpCode.Decompiler/CSharp/CallBuilder.cs
+++ b/ICSharpCode.Decompiler/CSharp/CallBuilder.cs
@@ -1658,7 +1658,7 @@ OverloadResolutionErrors IsUnambiguousCall(ExpectedTargetDetails expectedTargetD
 					}
 				}
 			}
-			else if (method.IsOperator)
+			else if (method.IsOperator && method.IsStatic)
 			{
 				IEnumerable<IParameterizedMember> operatorCandidates;
 				if (arguments.Length == 1)
@@ -1694,6 +1694,23 @@ OverloadResolutionErrors IsUnambiguousCall(ExpectedTargetDetails expectedTargetD
 					or.AddCandidate(m);
 				}
 			}
+			else if (settings.UserDefinedCompoundAssignmentOperators && method.IsOperator && !method.IsStatic && target != null)
+			{
+				// An instance operator has no callable spelling of its own: it is only ever emitted
+				// as "x op= y" or "x++". C# resolves that form in two phases, the instance operators
+				// on the static type of x first and the static operators only if none of them is
+				// applicable, so these candidates are the whole of what recompilation considers here.
+				// The fallback phase is not modelled: a call this set cannot account for gives up the
+				// operator form rather than being checked against the static operators, since a match
+				// there would emit the operator form for a call C# resolves to a different method.
+				// The reverse direction - a static operator call that must not be folded because the
+				// first phase would take it - uses the same candidate set, see
+				// CSharpResolver.IsShadowedByInstanceOperator.
+				foreach (var m in CSharpResolver.GetInstanceOperatorCandidates(resolver.Compilation, target.Type, method.Name, arguments))
+				{
+					or.AddCandidate(m);
+				}
+			}
 			else if (target == null)
 			{
 				var result = resolver.ResolveSimpleName(method.Name, typeArguments, isInvocationTarget: true)
diff --git a/ICSharpCode.Decompiler/CSharp/ExpressionBuilder.cs b/ICSharpCode.Decompiler/CSharp/ExpressionBuilder.cs
index a59e50abf8..b2d3f1a90c 100644
--- a/ICSharpCode.Decompiler/CSharp/ExpressionBuilder.cs
+++ b/ICSharpCode.Decompiler/CSharp/ExpressionBuilder.cs
@@ -853,10 +853,23 @@ protected internal override TranslatedExpression VisitLdLoca(LdLoca inst, Transl
 				.WithRR(new ByReferenceResolveResult(expr.ResolveResult, ReferenceKind.Ref));
 		}
 
+		/// <summary>
+		/// Gets whether the variable still carries the type the ILReader hands a stack slot, which is
+		/// derived from the stack type alone and therefore says nothing about the value stored in it.
+		/// A slot that was given a type on purpose has to keep it.
+		/// </summary>
+		bool HasDefaultStackSlotType(ILVariable variable)
+		{
+			if (variable.Type.Equals(compilation.FindType(variable.StackType)))
+				return true;
+			// native ints reach the C# layer as nint/nuint rather than as the IntPtr the reader used.
+			return variable.StackType == StackType.I && variable.Type.Kind is TypeKind.NInt or TypeKind.NUInt;
+		}
+
 		protected internal override TranslatedExpression VisitStLoc(StLoc inst, TranslationContext context)
 		{
 			var translatedValue = Translate(inst.Value, typeHint: inst.Variable.Type);
-			if (inst.Variable.Kind == VariableKind.StackSlot && !loadedVariablesSet.Contains(inst.Variable))
+			if (inst.Variable.Kind == VariableKind.StackSlot && !loadedVariablesSet.Contains(inst.Variable) && HasDefaultStackSlotType(inst.Variable))
 			{
 				// Stack slots in the ILAst have inaccurate types (e.g. System.Object for StackType.O)
 				// so we should replace them with more accurate types where possible:
diff --git a/ICSharpCode.Decompiler/CSharp/OutputVisitor/CSharpAmbience.cs b/ICSharpCode.Decompiler/CSharp/OutputVisitor/CSharpAmbience.cs
index 509c3ea7c4..12e4314f09 100644
--- a/ICSharpCode.Decompiler/CSharp/OutputVisitor/CSharpAmbience.cs
+++ b/ICSharpCode.Decompiler/CSharp/OutputVisitor/CSharpAmbience.cs
@@ -286,6 +286,7 @@ TypeSystemAstBuilder CreateAstBuilder()
 			astBuilder.SupportUnsignedRightShift = (ConversionFlags & ConversionFlags.SupportUnsignedRightShift) != 0;
 			astBuilder.SupportOperatorChecked = (ConversionFlags & ConversionFlags.SupportOperatorChecked) != 0;
 			astBuilder.SupportExtensionDeclarations = (ConversionFlags & ConversionFlags.SupportExtensionDeclarations) != 0;
+			astBuilder.SupportUserDefinedCompoundAssignmentOperators = (ConversionFlags & ConversionFlags.SupportUserDefinedCompoundAssignmentOperators) != 0;
 			return astBuilder;
 		}
 
@@ -394,7 +395,8 @@ void WriteMemberDeclarationName(IMember member, TokenWriter writer, CSharpFormat
 							writer.WriteKeyword("operator");
 							writer.Space();
 							var operatorType = OperatorDeclaration.GetOperatorType(name);
-							if (operatorType.HasValue && !((ConversionFlags & ConversionFlags.SupportOperatorChecked) == 0 && OperatorDeclaration.IsChecked(operatorType.Value)))
+							if (operatorType.HasValue && !((ConversionFlags & ConversionFlags.SupportOperatorChecked) == 0 && OperatorDeclaration.IsChecked(operatorType.Value))
+								&& !((ConversionFlags & ConversionFlags.SupportUserDefinedCompoundAssignmentOperators) == 0 && OperatorDeclaration.IsCompoundAssignment(operatorType.Value)))
 							{
 								if (OperatorDeclaration.IsChecked(operatorType.Value))
 								{
diff --git a/ICSharpCode.Decompiler/CSharp/Resolver/CSharpResolver.cs b/ICSharpCode.Decompiler/CSharp/Resolver/CSharpResolver.cs
index 2cd0f341d5..ea1c8a37ab 100644
--- a/ICSharpCode.Decompiler/CSharp/Resolver/CSharpResolver.cs
+++ b/ICSharpCode.Decompiler/CSharp/Resolver/CSharpResolver.cs
@@ -1245,6 +1245,191 @@ public IEnumerable<IParameterizedMember> GetUserDefinedOperatorCandidates(IType
 			return operators;
 		}
 
+		#region C# 14 user-defined compound assignment operator binding
+		/// <summary>
+		/// Gets the C# 14 instance compound assignment operators that "x op= y" considers when x
+		/// has the type <paramref name="targetType"/>.
+		/// </summary>
+		/// <remarks>
+		/// Ordinary member lookup skips operators, so they have to be collected from the type by
+		/// hand. C# requires a user-defined operator to be public (CS9308), so one that is not
+		/// cannot be bound in operator form at all.
+		/// </remarks>
+		public static List<IMethod> GetInstanceOperatorCandidates(IType targetType, string name)
+		{
+			var candidates = targetType.GetMethods(
+				m => m.IsOperator && !m.IsStatic && m.Accessibility == Accessibility.Public && m.Name == name
+			).ToList();
+			// An override and the member it overrides share a signature; member lookup keeps only
+			// the most derived one, and passing both to overload resolution would make every call
+			// ambiguous.
+			return candidates.Where(
+				m => !candidates.Any(other => other != m
+					&& InheritanceHelper.GetBaseMembers(other, includeImplementedInterfaces: false)
+						.Any(b => b.MemberDefinition == m.MemberDefinition))
+			).ToList();
+		}
+
+		/// <summary>
+		/// Gets whether "x op= y" would bind a C# 14 instance compound assignment operator instead
+		/// of <paramref name="method"/>, the static operator the IL calls, where x has the type
+		/// <paramref name="targetType"/> and y the type <paramref name="valueType"/>
+		/// (null for the increment and decrement operators, which take no argument).
+		/// </summary>
+		/// <param name="targetIsVariable">
+		/// Whether x denotes a storage location. An instance operator mutates its receiver in
+		/// place, so C# only considers one where x is a variable; for a property or an indexer the
+		/// first phase described below does not happen at all.
+		/// </param>
+		/// <remarks>
+		/// C# resolves "x op= y" in two phases: the instance operators reachable from the static
+		/// type of x are considered first, and the static operators only if none of them is
+		/// applicable. An applicable instance operator wins even where a static one would be the
+		/// better match by conversion, and one inherited from a base class beats a static operator
+		/// declared on the target's own type. Folding "x = x op y" into "x op= y" is therefore only
+		/// safe while the first phase comes up empty.
+		/// </remarks>
+		public static bool IsShadowedByInstanceOperator(IMethod method, IType targetType, IType valueType,
+			bool targetIsVariable, ICompilation compilation)
+		{
+			if (!targetIsVariable)
+				return false;
+			string name = GetCompoundAssignmentOperatorName(method.Name);
+			if (name == null)
+				return false;
+			// Both the checked and the unchecked instance operator can take the call: which of them
+			// applies depends on the checked context the assignment ends up in.
+			string checkedName = "op_Checked" + name.Substring("op_".Length);
+			var candidates = GetInstanceOperatorCandidates(targetType, name);
+			candidates.AddRange(GetInstanceOperatorCandidates(targetType, checkedName));
+			if (candidates.Count == 0)
+				return false;
+			ResolveResult[] arguments = valueType == null
+				? []
+				: [new ResolveResult(valueType)];
+			var or = new OverloadResolution(compilation, arguments);
+			foreach (var candidate in candidates)
+			{
+				or.AddCandidate(candidate);
+			}
+			return or.FoundApplicableCandidate;
+		}
+
+		/// <summary>
+		/// Gets the candidates of <see cref="GetInstanceOperatorCandidates(IType, string)"/> reduced
+		/// the way C# overload resolution reduces them for the given arguments: a candidate declared
+		/// in a base type is removed when a candidate declared in a more derived type is applicable.
+		/// An applicable operator on the receiver's own type therefore takes the call even where a
+		/// base-type operator would be the better match by conversion.
+		/// </summary>
+		public static List<IMethod> GetInstanceOperatorCandidates(ICompilation compilation, IType targetType, string name, ResolveResult[] arguments)
+		{
+			return PruneCandidatesHiddenByDerivedApplicable(GetInstanceOperatorCandidates(targetType, name), arguments, compilation);
+		}
+
+		static List<IMethod> PruneCandidatesHiddenByDerivedApplicable(List<IMethod> candidates, ResolveResult[] arguments, ICompilation compilation)
+		{
+			if (candidates.Count <= 1)
+				return candidates;
+			var applicable = candidates.Where(c => IsApplicable(c, arguments, compilation)).ToList();
+			if (applicable.Count == 0)
+				return candidates;
+			return candidates.Where(
+				c => !applicable.Any(a => a.DeclaringTypeDefinition != c.DeclaringTypeDefinition
+					&& a.DeclaringTypeDefinition != null && c.DeclaringTypeDefinition != null
+					&& a.DeclaringTypeDefinition.GetAllBaseTypeDefinitions().Contains(c.DeclaringTypeDefinition))
+			).ToList();
+		}
+
+		static bool IsApplicable(IMethod candidate, ResolveResult[] arguments, ICompilation compilation)
+		{
+			var or = new OverloadResolution(compilation, arguments);
+			or.AddCandidate(candidate);
+			return or.FoundApplicableCandidate;
+		}
+
+		/// <summary>
+		/// Gets whether "x op= y", where x has the type <paramref name="receiverType"/>, would bind
+		/// an operator other than <paramref name="called"/> - the one the call being rewritten names.
+		/// </summary>
+		/// <remarks>
+		/// The form takes its operator from the static type of x, so an expression standing in for
+		/// the receiver must be one that still selects the same operator: a more derived type can
+		/// hide it. The cast that would pin the type down is not a valid assignment target, so the
+		/// receiver has to keep a type that binds what the call names.
+		///
+		/// A type that carries no operator of this name at all is not a rebinding: several ILAst
+		/// nodes are typed by their stack type rather than by the C# type they will be written as,
+		/// and the C# layer resolves those itself.
+		/// </remarks>
+		public static bool WouldRebindOperator(IMethod called, IType receiverType, ICompilation compilation)
+		{
+			ResolveResult[] arguments = called.Parameters.Count == 0
+				? []
+				: [new ResolveResult(called.Parameters[0].Type)];
+			return WouldRebindOperator(called, receiverType, arguments, compilation);
+		}
+
+		/// <summary>
+		/// Gets whether "x op= y", where x has the type <paramref name="receiverType"/> and y is
+		/// described by <paramref name="arguments"/>, would bind an operator other than
+		/// <paramref name="called"/>. The operator form has no way to pick an overload by
+		/// parameter modifier, so a call to an "in" overload whose by-value sibling is applicable
+		/// cannot be folded.
+		/// </summary>
+		public static bool WouldRebindOperator(IMethod called, IType receiverType, ResolveResult[] arguments, ICompilation compilation)
+		{
+			if (called.DeclaringType.Kind == TypeKind.Interface
+				&& receiverType.Kind is not (TypeKind.Interface or TypeKind.TypeParameter)
+				&& !receiverType.IsKnownType(KnownTypeCode.Object))
+			{
+				// An operator declared in an interface is only reachable from a receiver of
+				// interface (or type-parameter) type: class member lookup does not see
+				// interface members, so a class-typed replacement cannot bind the call.
+				// System.Object stays permissive - it is the stack-type placeholder several
+				// ILAst nodes carry.
+				return true;
+			}
+			var candidates = GetInstanceOperatorCandidates(compilation, receiverType, called.Name, arguments);
+			if (candidates.Count == 0)
+				return false;
+			var or = new OverloadResolution(compilation, arguments);
+			foreach (var candidate in candidates)
+			{
+				or.AddCandidate(candidate);
+			}
+			if (!or.FoundApplicableCandidate || or.BestCandidate is not IMethod best)
+				return false;
+			// An override occupies the slot of the operator the call names, so binding to it is
+			// binding to the call; a "new" member only shares the signature.
+			if (best.Equals(called))
+				return false;
+			return !(best.IsOverride
+				&& InheritanceHelper.GetBaseMembers(best, includeImplementedInterfaces: false)
+					.Any(m => m.MemberDefinition == called.MemberDefinition));
+		}
+
+		static string GetCompoundAssignmentOperatorName(string staticOperatorName)
+		{
+			return staticOperatorName switch {
+				"op_Addition" or "op_CheckedAddition" => "op_AdditionAssignment",
+				"op_Subtraction" or "op_CheckedSubtraction" => "op_SubtractionAssignment",
+				"op_Multiply" or "op_CheckedMultiply" => "op_MultiplicationAssignment",
+				"op_Division" or "op_CheckedDivision" => "op_DivisionAssignment",
+				"op_Modulus" => "op_ModulusAssignment",
+				"op_BitwiseAnd" => "op_BitwiseAndAssignment",
+				"op_BitwiseOr" => "op_BitwiseOrAssignment",
+				"op_ExclusiveOr" => "op_ExclusiveOrAssignment",
+				"op_LeftShift" => "op_LeftShiftAssignment",
+				"op_RightShift" => "op_RightShiftAssignment",
+				"op_UnsignedRightShift" => "op_UnsignedRightShiftAssignment",
+				"op_Increment" or "op_CheckedIncrement" => "op_IncrementAssignment",
+				"op_Decrement" or "op_CheckedDecrement" => "op_DecrementAssignment",
+				_ => null,
+			};
+		}
+		#endregion
+
 		void LiftUserDefinedOperators(List<IMethod> operators)
 		{
 			int nonLiftedMethodCount = operators.Count;
diff --git a/ICSharpCode.Decompiler/CSharp/StatementBuilder.cs b/ICSharpCode.Decompiler/CSharp/StatementBuilder.cs
index 3eeb55e89f..e5cd99a1f2 100644
--- a/ICSharpCode.Decompiler/CSharp/StatementBuilder.cs
+++ b/ICSharpCode.Decompiler/CSharp/StatementBuilder.cs
@@ -821,18 +821,31 @@ bool EnumeratorTypeCanNeverBeDisposable(IType type)
 					body.Instructions.Insert(0, new StLoc(foreachVariable, instToReplace));
 					break;
 				case RequiredGetCurrentTransformation.IntroduceNewVariableAndLocalCopy:
+				{
+					// The local copy is the existing variable the loop body stores Current into,
+					// if there is one; otherwise a fresh local replaces the address-of expression.
+					ILVariable? localCopyVariable = foreachVariable;
 					foreachVariable = currentFunction.RegisterVariable(
 						VariableKind.ForeachLocal, type,
 						AssignVariableNames.GenerateForeachVariableName(currentFunction, collectionExpr.Annotation<ILInstruction>(), decompileRun.UsingScope)
 					);
-					var localCopyVariable = currentFunction.RegisterVariable(
-						VariableKind.Local, type,
-						AssignVariableNames.GenerateVariableName(currentFunction, type, decompileRun.UsingScope)
-					);
-					instToReplace.Parent!.ReplaceWith(new LdLoca(localCopyVariable));
-					body.Instructions.Insert(0, new StLoc(localCopyVariable, new LdLoc(foreachVariable)));
+					if (localCopyVariable != null)
+					{
+						localCopyVariable.Name = AssignVariableNames.GenerateVariableName(currentFunction, type, decompileRun.UsingScope);
+						instToReplace.ReplaceWith(new LdLoc(foreachVariable));
+					}
+					else
+					{
+						localCopyVariable = currentFunction.RegisterVariable(
+							VariableKind.Local, type,
+							AssignVariableNames.GenerateVariableName(currentFunction, type, decompileRun.UsingScope)
+						);
+						instToReplace.Parent!.ReplaceWith(new LdLoca(localCopyVariable));
+						body.Instructions.Insert(0, new StLoc(localCopyVariable, new LdLoc(foreachVariable)));
+					}
 					body.Instructions.Insert(0, new StLoc(foreachVariable, instToReplace));
 					break;
+				}
 				case RequiredGetCurrentTransformation.Deconstruction:
 					useVar = true;
 					designation = TranslateDeconstructionDesignation((DeconstructInstruction)body.Instructions[0], isForeach: true);
@@ -1029,6 +1042,17 @@ enum RequiredGetCurrentTransformation
 			///	stloc copy(ldloc foreachVar)
 			///	... (ldloca copy) ...
 			/// </code>
+			/// The same applies when the value is stored into an existing variable that is the
+			/// receiver of an instance compound assignment operator, which a read-only foreach
+			/// variable cannot be: that variable stays the writable local copy.
+			/// <code>
+			///	stloc existing(call get_Current())
+			///	... existing op= ...
+			///	=>
+			///	stloc foreachVar(call get_Current())
+			///	stloc existing(ldloc foreachVar)
+			///	... existing op= ...
+			/// </code>
 			/// </summary>
 			IntroduceNewVariableAndLocalCopy,
 			/// <summary>
@@ -1085,6 +1109,13 @@ RequiredGetCurrentTransformation DetectGetCurrentTransformation(BlockContainer u
 				if (stloc.Parent == loopBody && VariableIsOnlyUsedInBlock(stloc, usingContainer, loopContainer))
 				{
 					foreachVariable = stloc.Variable;
+					if (settings.UserDefinedCompoundAssignmentOperators
+						&& UserDefinedCompoundAssign.IsCompoundAssignmentReceiver(stloc.Variable))
+					{
+						// A foreach variable is read-only, but an instance compound assignment
+						// operator requires an assignable target: keep the variable as the copy.
+						return RequiredGetCurrentTransformation.IntroduceNewVariableAndLocalCopy;
+					}
 					return RequiredGetCurrentTransformation.UseExistingVariable;
 				}
 			}
diff --git a/ICSharpCode.Decompiler/CSharp/Syntax/TypeMembers/OperatorDeclaration.cs b/ICSharpCode.Decompiler/CSharp/Syntax/TypeMembers/OperatorDeclaration.cs
index 86bb76c76b..a7f303bb76 100644
--- a/ICSharpCode.Decompiler/CSharp/Syntax/TypeMembers/OperatorDeclaration.cs
+++ b/ICSharpCode.Decompiler/CSharp/Syntax/TypeMembers/OperatorDeclaration.cs
@@ -75,7 +75,31 @@ public enum OperatorType
 		// Implicit and Explicit
 		Implicit,
 		Explicit,
-		CheckedExplicit
+		CheckedExplicit,
+
+		// C# 14 user-defined compound assignment (void-returning instance operators).
+		// IsCompoundAssignment tells these apart by comparing against AdditionAssignment, so they
+		// have to stay last as a block: a member added after them would be taken for one of them,
+		// and one added before would stop being recognized.
+		AdditionAssignment,
+		CheckedAdditionAssignment,
+		SubtractionAssignment,
+		CheckedSubtractionAssignment,
+		MultiplicationAssignment,
+		CheckedMultiplicationAssignment,
+		DivisionAssignment,
+		CheckedDivisionAssignment,
+		ModulusAssignment,
+		BitwiseAndAssignment,
+		BitwiseOrAssignment,
+		ExclusiveOrAssignment,
+		LeftShiftAssignment,
+		RightShiftAssignment,
+		UnsignedRightShiftAssignment,
+		IncrementAssignment,
+		CheckedIncrementAssignment,
+		DecrementAssignment,
+		CheckedDecrementAssignment
 	}
 
 	/// <summary>
@@ -100,7 +124,7 @@ public sealed partial class OperatorDeclaration : EntityDeclaration
 
 		static OperatorDeclaration()
 		{
-			names = new string[(int)OperatorType.CheckedExplicit + 1][];
+			names = new string[(int)OperatorType.CheckedDecrementAssignment + 1][];
 			names[(int)OperatorType.LogicalNot] = new string[] { "!", "op_LogicalNot" };
 			names[(int)OperatorType.OnesComplement] = new string[] { "~", "op_OnesComplement" };
 			names[(int)OperatorType.Increment] = new string[] { "++", "op_Increment" };
@@ -136,6 +160,25 @@ static OperatorDeclaration()
 			names[(int)OperatorType.Implicit] = new string[] { "implicit", "op_Implicit" };
 			names[(int)OperatorType.Explicit] = new string[] { "explicit", "op_Explicit" };
 			names[(int)OperatorType.CheckedExplicit] = new string[] { "explicit", "op_CheckedExplicit" };
+			names[(int)OperatorType.AdditionAssignment] = new string[] { "+=", "op_AdditionAssignment" };
+			names[(int)OperatorType.CheckedAdditionAssignment] = new string[] { "+=", "op_CheckedAdditionAssignment" };
+			names[(int)OperatorType.SubtractionAssignment] = new string[] { "-=", "op_SubtractionAssignment" };
+			names[(int)OperatorType.CheckedSubtractionAssignment] = new string[] { "-=", "op_CheckedSubtractionAssignment" };
+			names[(int)OperatorType.MultiplicationAssignment] = new string[] { "*=", "op_MultiplicationAssignment" };
+			names[(int)OperatorType.CheckedMultiplicationAssignment] = new string[] { "*=", "op_CheckedMultiplicationAssignment" };
+			names[(int)OperatorType.DivisionAssignment] = new string[] { "/=", "op_DivisionAssignment" };
+			names[(int)OperatorType.CheckedDivisionAssignment] = new string[] { "/=", "op_CheckedDivisionAssignment" };
+			names[(int)OperatorType.ModulusAssignment] = new string[] { "%=", "op_ModulusAssignment" };
+			names[(int)OperatorType.BitwiseAndAssignment] = new string[] { "&=", "op_BitwiseAndAssignment" };
+			names[(int)OperatorType.BitwiseOrAssignment] = new string[] { "|=", "op_BitwiseOrAssignment" };
+			names[(int)OperatorType.ExclusiveOrAssignment] = new string[] { "^=", "op_ExclusiveOrAssignment" };
+			names[(int)OperatorType.LeftShiftAssignment] = new string[] { "<<=", "op_LeftShiftAssignment" };
+			names[(int)OperatorType.RightShiftAssignment] = new string[] { ">>=", "op_RightShiftAssignment" };
+			names[(int)OperatorType.UnsignedRightShiftAssignment] = new string[] { ">>>=", "op_UnsignedRightShiftAssignment" };
+			names[(int)OperatorType.IncrementAssignment] = new string[] { "++", "op_IncrementAssignment" };
+			names[(int)OperatorType.CheckedIncrementAssignment] = new string[] { "++", "op_CheckedIncrementAssignment" };
+			names[(int)OperatorType.DecrementAssignment] = new string[] { "--", "op_DecrementAssignment" };
+			names[(int)OperatorType.CheckedDecrementAssignment] = new string[] { "--", "op_CheckedDecrementAssignment" };
 		}
 
 		public override SymbolKind SymbolKind {
@@ -201,10 +244,25 @@ public static bool IsChecked(OperatorType type)
 				OperatorType.CheckedIncrement => true,
 				OperatorType.CheckedDecrement => true,
 				OperatorType.CheckedExplicit => true,
+				OperatorType.CheckedAdditionAssignment => true,
+				OperatorType.CheckedSubtractionAssignment => true,
+				OperatorType.CheckedMultiplicationAssignment => true,
+				OperatorType.CheckedDivisionAssignment => true,
+				OperatorType.CheckedIncrementAssignment => true,
+				OperatorType.CheckedDecrementAssignment => true,
 				_ => false,
 			};
 		}
 
+		/// <summary>
+		/// Gets whether the operator type is a C# 14 user-defined compound assignment operator
+		/// (a void-returning instance operator, including the increment/decrement forms).
+		/// </summary>
+		public static bool IsCompoundAssignment(OperatorType type)
+		{
+			return type >= OperatorType.AdditionAssignment;
+		}
+
 		/// <summary>
 		/// Gets the token for the operator type ("+", "implicit", etc.).
 		/// Does not include the "checked" modifier.
diff --git a/ICSharpCode.Decompiler/CSharp/Syntax/TypeSystemAstBuilder.cs b/ICSharpCode.Decompiler/CSharp/Syntax/TypeSystemAstBuilder.cs
index e3c66d95e8..94e7028de8 100644
--- a/ICSharpCode.Decompiler/CSharp/Syntax/TypeSystemAstBuilder.cs
+++ b/ICSharpCode.Decompiler/CSharp/Syntax/TypeSystemAstBuilder.cs
@@ -260,6 +260,11 @@ void InitProperties()
 		/// Controls whether C# 14 "extension" declarations are supported.
 		/// </summary>
 		public bool SupportExtensionDeclarations { get; set; }
+
+		/// <summary>
+		/// Controls whether C# 14 user-defined compound assignment operators ("operator +=") are supported.
+		/// </summary>
+		public bool SupportUserDefinedCompoundAssignmentOperators { get; set; }
 		#endregion
 
 		#region Convert Type
@@ -2556,7 +2561,15 @@ EntityDeclaration ConvertOperator(IMethod op)
 			OperatorType? opType = OperatorDeclaration.GetOperatorType(name);
 			if (opType == null)
 				return ConvertMethod(op);
-			if (opType == OperatorType.UnsignedRightShift && !SupportUnsignedRightShift)
+			if (opType is OperatorType.UnsignedRightShift or OperatorType.UnsignedRightShiftAssignment && !SupportUnsignedRightShift)
+				return ConvertMethod(op);
+			if (!SupportUserDefinedCompoundAssignmentOperators && OperatorDeclaration.IsCompoundAssignment(opType.Value))
+				return ConvertMethod(op);
+			// C# requires a user-defined operator to be public, so a compound assignment operator
+			// that is not can only be written as a plain method. An explicit interface
+			// implementation is private in metadata but is still written in operator form.
+			if (OperatorDeclaration.IsCompoundAssignment(opType.Value)
+				&& op.Accessibility != Accessibility.Public && !op.IsExplicitInterfaceImplementation)
 				return ConvertMethod(op);
 			if (!SupportOperatorChecked && OperatorDeclaration.IsChecked(opType.Value))
 				return ConvertMethod(op);
diff --git a/ICSharpCode.Decompiler/CSharp/Transforms/PatternStatementTransform.cs b/ICSharpCode.Decompiler/CSharp/Transforms/PatternStatementTransform.cs
index 2f4adf6e40..3ed850d394 100644
--- a/ICSharpCode.Decompiler/CSharp/Transforms/PatternStatementTransform.cs
+++ b/ICSharpCode.Decompiler/CSharp/Transforms/PatternStatementTransform.cs
@@ -323,6 +323,14 @@ bool VariableCanBeUsedAsForeachLocal(IL.ILVariable itemVar, Statement loop)
 				return false;
 			}
 
+			if (context.Settings.UserDefinedCompoundAssignmentOperators
+				&& IL.UserDefinedCompoundAssign.IsCompoundAssignmentReceiver(itemVar))
+			{
+				// A foreach variable is read-only, but an instance compound assignment operator
+				// requires an assignable target; the plain loop keeps the variable writable.
+				return false;
+			}
+
 			var blockContainer = loop.Annotation<IL.BlockContainer>();
 
 			if (!itemVar.IsSingleDefinition)
@@ -662,6 +670,8 @@ bool MatchForeachOnMultiDimArray(IL.ILVariable[] upperBounds, IL.ILVariable coll
 			var itemVariable = foreachVariable.GetILVariable();
 			if (itemVariable == null || !itemVariable.IsSingleDefinition
 				|| (itemVariable.Kind != IL.VariableKind.Local && itemVariable.Kind != IL.VariableKind.StackSlot)
+				|| (context.Settings.UserDefinedCompoundAssignmentOperators
+					&& IL.UserDefinedCompoundAssign.IsCompoundAssignmentReceiver(itemVariable))
 				|| !upperBounds.All(ub => ub.IsSingleDefinition && ub.LoadCount == 1)
 				|| !lowerBounds.All(lb => lb.StoreCount == 2 && lb.LoadCount == 3 && lb.AddressCount == 0))
 				return null;
diff --git a/ICSharpCode.Decompiler/CSharp/Transforms/PrettifyAssignments.cs b/ICSharpCode.Decompiler/CSharp/Transforms/PrettifyAssignments.cs
index 9c89119b0e..2ce85b2768 100644
--- a/ICSharpCode.Decompiler/CSharp/Transforms/PrettifyAssignments.cs
+++ b/ICSharpCode.Decompiler/CSharp/Transforms/PrettifyAssignments.cs
@@ -61,7 +61,8 @@ public override void VisitAssignmentExpression(AssignmentExpression assignment)
 			if (rhs is BinaryOperatorExpression binary && assignment.Operator == AssignmentOperatorType.Assign)
 			{
 				if (CanConvertToCompoundAssignment(assignment.Left) && assignment.Left.IsMatch(binary.Left)
-					&& binary.Right != null && IsImplicitlyConvertible(binary.Right, expectedType))
+					&& binary.Right != null && IsImplicitlyConvertible(binary.Right, expectedType)
+					&& !IsShadowedByInstanceOperator(binary))
 				{
 					var newOperator = GetAssignmentOperatorForBinaryOperator(binary.Operator);
 					if (newOperator != AssignmentOperatorType.Assign)
@@ -102,6 +103,18 @@ public override void VisitAssignmentExpression(AssignmentExpression assignment)
 				}
 			}
 
+			bool IsShadowedByInstanceOperator(BinaryOperatorExpression binary)
+			{
+				// "x = x + y" must keep calling the static operator wherever "x += y" would find an
+				// applicable C# 14 instance operator on the static type of x: that form considers
+				// the instance operators first and only falls back to the static ones.
+				return binary.Right != null && binary.GetSymbol() is IMethod method
+					&& CSharpResolver.IsShadowedByInstanceOperator(method,
+						assignment.Left.GetResolveResult().Type, binary.Right.GetResolveResult().Type,
+						targetIsVariable: assignment.Left.GetSymbol() is not IProperty,
+						context.TypeSystem);
+			}
+
 			bool IsImplicitlyConvertible(Expression rhs, IType? expectedType)
 			{
 				if (expectedType == null)
diff --git a/ICSharpCode.Decompiler/CSharp/Transforms/ReplaceMethodCallsWithOperators.cs b/ICSharpCode.Decompiler/CSharp/Transforms/ReplaceMethodCallsWithOperators.cs
index 6136ec4963..ac1e94a5be 100644
--- a/ICSharpCode.Decompiler/CSharp/Transforms/ReplaceMethodCallsWithOperators.cs
+++ b/ICSharpCode.Decompiler/CSharp/Transforms/ReplaceMethodCallsWithOperators.cs
@@ -26,6 +26,7 @@
 using ICSharpCode.Decompiler.CSharp.Syntax;
 using ICSharpCode.Decompiler.CSharp.Syntax.PatternMatching;
 using ICSharpCode.Decompiler.Semantics;
+using ICSharpCode.Decompiler.CSharp.Resolver;
 using ICSharpCode.Decompiler.TypeSystem;
 using ICSharpCode.Decompiler.Util;
 
@@ -192,6 +193,91 @@ void ProcessInvocationExpression(InvocationExpression invocationExpression)
 				context.EndStep(binaryOperator);
 				return;
 			}
+			// Accessibility is part of whether "x op= y" can bind here at all: C# requires a
+			// user-defined operator to be public, so a call to one that is not has to stay a call.
+			if (context.Settings.UserDefinedCompoundAssignmentOperators
+				&& method is { IsOperator: true, IsStatic: false, Accessibility: Accessibility.Public }
+				&& invocationExpression.Target is MemberReferenceExpression or PointerReferenceExpression)
+			{
+				// A pointer indirection is always an assignable variable; every other receiver
+				// has to pass the target checks.
+				bool receiverIsPointer = invocationExpression.Target is PointerReferenceExpression;
+				Expression receiver = invocationExpression.Target switch {
+					MemberReferenceExpression mre => mre.Target,
+					_ => ((PointerReferenceExpression)invocationExpression.Target).Target,
+				};
+				if (!receiverIsPointer && (!IsValidAssignmentTarget(receiver) || !IsAssignableTarget(receiver)))
+					return;
+				if (!receiverIsPointer && method.DeclaringType.Kind == TypeKind.Interface
+					&& receiver.GetResolveResult().Type.Kind is not (TypeKind.Interface or TypeKind.TypeParameter))
+				{
+					// An operator declared in an interface (an explicit implementation, say)
+					// can only be bound through a receiver of interface or type-parameter type.
+					return;
+				}
+				Expression MakeAssignmentTarget()
+				{
+					Expression target = receiver.Detach();
+					return receiverIsPointer
+						? new UnaryOperatorExpression(UnaryOperatorType.Dereference, target)
+						: target;
+				}
+				AssignmentOperatorType? aop = GetCompoundAssignmentOperatorTypeFromMetadataName(method.Name, out isChecked, context.Settings);
+				if (aop != null && arguments.Length == 1)
+				{
+					// "x op= y" takes its operator from the static type of x and the type of y; it
+					// has no way to select an overload by parameter modifier, so a call the form
+					// would bind differently (an "in" overload beside an applicable by-value one)
+					// has to stay a call.
+					Expression value = arguments[0] is DirectionExpression direction ? direction.Expression : arguments[0];
+					IType receiverType = receiverIsPointer
+						? ((PointerType)receiver.GetResolveResult().Type).ElementType
+						: receiver.GetResolveResult().Type;
+					if (CSharpResolver.WouldRebindOperator(method, receiverType, [value.GetResolveResult()], context.TypeSystem))
+						return;
+					context.Step("Replace instance operator method with compound assignment", invocationExpression);
+					if (isChecked)
+					{
+						invocationExpression.AddAnnotation(AddCheckedBlocks.CheckedAnnotation);
+					}
+					else if (HasCheckedEquivalent(method))
+					{
+						invocationExpression.AddAnnotation(AddCheckedBlocks.UncheckedAnnotation);
+					}
+					var assignment = new AssignmentExpression(
+						MakeAssignmentTarget(),
+						aop.Value,
+						arguments[0].Detach().UnwrapInDirectionExpression()
+					).CopyAnnotationsFrom(invocationExpression);
+					invocationExpression.ReplaceWith(assignment);
+					context.EndStep(assignment);
+					return;
+				}
+				UnaryOperatorType? incDecOp = method.Name switch {
+					"op_IncrementAssignment" => UnaryOperatorType.PostIncrement,
+					"op_DecrementAssignment" => UnaryOperatorType.PostDecrement,
+					"op_CheckedIncrementAssignment" when context.Settings.CheckedOperators => UnaryOperatorType.PostIncrement,
+					"op_CheckedDecrementAssignment" when context.Settings.CheckedOperators => UnaryOperatorType.PostDecrement,
+					_ => null,
+				};
+				if (incDecOp != null && arguments.Length == 0)
+				{
+					context.Step("Replace instance operator method with increment/decrement", invocationExpression);
+					if (method.Name is "op_CheckedIncrementAssignment" or "op_CheckedDecrementAssignment")
+					{
+						invocationExpression.AddAnnotation(AddCheckedBlocks.CheckedAnnotation);
+					}
+					else if (HasCheckedEquivalent(method))
+					{
+						invocationExpression.AddAnnotation(AddCheckedBlocks.UncheckedAnnotation);
+					}
+					var incDec = new UnaryOperatorExpression(incDecOp.Value, MakeAssignmentTarget())
+						.CopyAnnotationsFrom(invocationExpression);
+					invocationExpression.ReplaceWith(incDec);
+					context.EndStep(incDec);
+					return;
+				}
+			}
 			UnaryOperatorType? uop = GetUnaryOperatorTypeFromMetadataName(method.Name, out isChecked, context.Settings);
 			if (uop != null && arguments.Length == 1)
 			{
@@ -517,6 +603,139 @@ static bool ToStringIsKnownEffectFree(IType type)
 			}
 		}
 
+		static AssignmentOperatorType? GetCompoundAssignmentOperatorTypeFromMetadataName(string name, out bool isChecked, DecompilerSettings settings)
+		{
+			isChecked = false;
+			switch (name)
+			{
+				case "op_AdditionAssignment":
+					return AssignmentOperatorType.Add;
+				case "op_CheckedAdditionAssignment" when settings.CheckedOperators:
+					isChecked = true;
+					return AssignmentOperatorType.Add;
+				case "op_SubtractionAssignment":
+					return AssignmentOperatorType.Subtract;
+				case "op_CheckedSubtractionAssignment" when settings.CheckedOperators:
+					isChecked = true;
+					return AssignmentOperatorType.Subtract;
+				case "op_MultiplicationAssignment":
+					return AssignmentOperatorType.Multiply;
+				case "op_CheckedMultiplicationAssignment" when settings.CheckedOperators:
+					isChecked = true;
+					return AssignmentOperatorType.Multiply;
+				case "op_DivisionAssignment":
+					return AssignmentOperatorType.Divide;
+				case "op_CheckedDivisionAssignment" when settings.CheckedOperators:
+					isChecked = true;
+					return AssignmentOperatorType.Divide;
+				case "op_ModulusAssignment":
+					return AssignmentOperatorType.Modulus;
+				case "op_BitwiseAndAssignment":
+					return AssignmentOperatorType.BitwiseAnd;
+				case "op_BitwiseOrAssignment":
+					return AssignmentOperatorType.BitwiseOr;
+				case "op_ExclusiveOrAssignment":
+					return AssignmentOperatorType.ExclusiveOr;
+				case "op_LeftShiftAssignment":
+					return AssignmentOperatorType.ShiftLeft;
+				case "op_RightShiftAssignment":
+					return AssignmentOperatorType.ShiftRight;
+				case "op_UnsignedRightShiftAssignment" when settings.UnsignedRightShift:
+					return AssignmentOperatorType.UnsignedShiftRight;
+				default:
+					return null;
+			}
+		}
+
+		/// <summary>
+		/// Gets whether the expression is classified as a variable, the only thing a user-defined
+		/// compound assignment operator can be applied to. Instance operator calls carry their
+		/// receiver as the call target, which is under no such restriction: properties and indexers
+		/// route through the static operator instead, and hand-written IL can call the operator on
+		/// any value at all.
+		/// </summary>
+		static bool IsValidAssignmentTarget(Expression expression)
+		{
+			if (IsWritableRefReturn(expression))
+				return true;
+			return expression switch {
+				BaseReferenceExpression => false,
+				// A pointer indirection is a variable.
+				UnaryOperatorExpression { Operator: UnaryOperatorType.Dereference } => true,
+				IndexerExpression => expression.GetSymbol() is not IProperty,
+				_ => expression.GetResolveResult() switch {
+					ILVariableResolveResult => true,
+					MemberResolveResult mrr => mrr.Member is IField,
+					_ => false,
+				}
+			};
+		}
+
+		/// <summary>
+		/// Gets whether the expression is a variable C# accepts as the target of "x op= y". The
+		/// target has to be assignable even though an instance operator never assigns to it:
+		/// "this" in a class, foreach, using and fixed variables, "in" parameters and readonly
+		/// fields outside the matching constructor are all rejected by the compiler.
+		/// </summary>
+		static bool IsAssignableTarget(Expression expression)
+		{
+			if (IsWritableRefReturn(expression))
+				return true;
+			if (expression is UnaryOperatorExpression { Operator: UnaryOperatorType.Dereference })
+			{
+				// A pointer indirection is never read-only.
+				return true;
+			}
+			if (expression is IndexerExpression)
+			{
+				// An array element (property indexers never get this far).
+				return true;
+			}
+			switch (expression.GetResolveResult())
+			{
+				case ThisResolveResult thisResolveResult:
+					// "this" is an assignable variable only in a struct, and only where the
+					// method does not make it read-only.
+					return thisResolveResult.Type.IsReferenceType != true
+						&& !thisResolveResult.Variable.IsRefReadOnly;
+				case ILVariableResolveResult vrr:
+					return !vrr.Variable.IsRefReadOnly
+						&& vrr.Variable.Kind is not (IL.VariableKind.ForeachLocal or IL.VariableKind.UsingLocal or IL.VariableKind.PinnedLocal);
+				case MemberResolveResult mrr when mrr.Member is IField field:
+					if (!field.IsReadOnly)
+						return true;
+					// A readonly field is a variable inside the matching constructor of its
+					// declaring type; an instance field additionally has to be accessed
+					// through "this".
+					return GetEnclosingMember(expression) is IMethod { IsConstructor: true } ctor
+						&& ctor.IsStatic == field.IsStatic
+						&& field.DeclaringTypeDefinition == ctor.DeclaringTypeDefinition
+						&& (field.IsStatic || mrr.TargetResult is ThisResolveResult);
+				default:
+					return false;
+			}
+		}
+
+		/// <summary>
+		/// Gets whether the expression denotes a writable ref-returning invocation or member
+		/// access. C# classifies those as variables, so they can take the place of x in
+		/// "x op= y"; a "ref readonly" return stays a read-only variable.
+		/// </summary>
+		static bool IsWritableRefReturn(Expression expression)
+		{
+			return expression.GetSymbol() is IMember { ReturnType: ByReferenceType } member
+				&& member switch {
+					IMethod method => !method.ReturnTypeIsRefReadOnly,
+					IProperty property => !property.ReturnTypeIsRefReadOnly,
+					_ => false,
+				};
+		}
+
+		static IMember? GetEnclosingMember(Expression expression)
+		{
+			return expression.Ancestors.OfType<EntityDeclaration>().FirstOrDefault()?.GetSymbol() as IMember;
+		}
+
 		static readonly Expression getMethodOrConstructorFromHandlePattern =
 			new CastExpression(new Choice {
 					 new TypePattern(typeof(MethodInfo)),
diff --git a/ICSharpCode.Decompiler/DecompilerSettings.cs b/ICSharpCode.Decompiler/DecompilerSettings.cs
index be0f91eebf..8728663a0a 100644
--- a/ICSharpCode.Decompiler/DecompilerSettings.cs
+++ b/ICSharpCode.Decompiler/DecompilerSettings.cs
@@ -862,6 +862,13 @@ public bool LifetimeAnnotations {
 		[DecompilerSetting(CSharp.LanguageVersion.CSharp14_0)]
 		public partial bool FieldKeyword { get; set; }
 
+		/// <summary>
+		/// Gets/Sets whether C# 14.0 user-defined compound assignment operators should be used.
+		/// </summary>
+		[Description("DecompilerSettings.UserDefinedCompoundAssignmentOperators")]
+		[DecompilerSetting(CSharp.LanguageVersion.CSharp14_0)]
+		public partial bool UserDefinedCompoundAssignmentOperators { get; set; }
+
 		/// <summary>
 		/// Gets/sets whether the decompiler should separate local variable declarations
 		/// from their initialization.
diff --git a/ICSharpCode.Decompiler/IL/ILReader.cs b/ICSharpCode.Decompiler/IL/ILReader.cs
index f051337bdc..bd73725c1b 100644
--- a/ICSharpCode.Decompiler/IL/ILReader.cs
+++ b/ICSharpCode.Decompiler/IL/ILReader.cs
@@ -1821,6 +1821,11 @@ bool ReceiverLooksLikeValueTypeTarget()
 					&& method.DeclaringType.IsReferenceType != true;
 			}
 
+			bool IsNonStaticOperatorCall()
+			{
+				return method.IsOperator && !method.IsStatic;
+			}
+
 			ILInstruction[] PrepareArguments(bool firstArgumentIsStObjTarget)
 			{
 				int firstArgument = (opCode != OpCode.NewObj && !method.IsStatic) ? 1 : 0;
@@ -1831,9 +1836,13 @@ ILInstruction[] PrepareArguments(bool firstArgumentIsStObjTarget)
 					&& !firstArgumentIsStObjTarget
 					&& UseRefLocalsForAccurateOrderOfEvaluation
 					&& expectedStackType == StackType.Ref && typeOfThis.IsReferenceType != false;
+				// Only an object reference is worth materializing: a value-type receiver is passed by
+				// address, so it already denotes a variable, and copying it into another one would
+				// make the operator mutate the copy.
+				bool materializeReceiver = IsNonStaticOperatorCall() && expectedStackType == StackType.O;
 				for (int i = method.Parameters.Count - 1; i >= 0; i--)
 				{
-					if (requiresLdObjIfRef)
+					if (requiresLdObjIfRef || materializeReceiver)
 					{
 						FlushExpressionStack();
 					}
@@ -1854,6 +1863,12 @@ ILInstruction[] PrepareArguments(bool firstArgumentIsStObjTarget)
 						{
 							firstArgumentInstruction = new LdObjIfRef(firstArgumentInstruction, typeOfThis);
 						}
+						else if (materializeReceiver)
+						{
+							Debug.Assert(currentBlock != null);
+							var v = AllocateStackSlot(firstArgumentInstruction, typeOfThis);
+							firstArgumentInstruction = new LdLoc(v);
+						}
 					}
 					arguments[0] = firstArgumentInstruction;
 				}
@@ -2107,15 +2122,23 @@ private void FlushExpressionStack()
 			foreach (var inst in expressionStack)
 			{
 				Debug.Assert(inst.ResultType != StackType.Void);
-				IType type = compilation.FindType(inst.ResultType);
-				var v = new ILVariable(VariableKind.StackSlot, type, inst.ResultType);
-				v.HasGeneratedName = true;
+				var v = AllocateStackSlot(inst, null);
 				currentStack = currentStack.Push(v);
-				currentBlock.Block.Instructions.Add(new StLoc(v, inst).WithILRange(inst));
 			}
 			expressionStack.Clear();
 		}
 
+		private ILVariable AllocateStackSlot(ILInstruction inst, IType? expectedType)
+		{
+			Debug.Assert(currentBlock != null);
+			IType type = expectedType ?? compilation.FindType(inst.ResultType);
+			Debug.Assert(type.GetStackType() == inst.ResultType);
+			var v = new ILVariable(VariableKind.StackSlot, type, inst.ResultType);
+			v.HasGeneratedName = true;
+			currentBlock.Block.Instructions.Add(new StLoc(v, inst).WithILRange(inst));
+			return v;
+		}
+
 		ILInstruction DecodeSwitch()
 		{
 			var targets = ILParser.DecodeSwitchTargets(ref reader);
diff --git a/ICSharpCode.Decompiler/IL/Instructions/CompoundAssignmentInstruction.cs b/ICSharpCode.Decompiler/IL/Instructions/CompoundAssignmentInstruction.cs
index 85f49aad6e..2d01782099 100644
--- a/ICSharpCode.Decompiler/IL/Instructions/CompoundAssignmentInstruction.cs
+++ b/ICSharpCode.Decompiler/IL/Instructions/CompoundAssignmentInstruction.cs
@@ -18,9 +18,13 @@
 // DEALINGS IN THE SOFTWARE.
 
 using System;
+using System.Collections.Generic;
 using System.Diagnostics;
+using System.Linq;
 using System.Linq.Expressions;
 
+using ICSharpCode.Decompiler.CSharp.Resolver;
+using ICSharpCode.Decompiler.Semantics;
 using ICSharpCode.Decompiler.TypeSystem;
 
 namespace ICSharpCode.Decompiler.IL
@@ -318,6 +322,11 @@ public UserDefinedCompoundAssign(IMethod method, CompoundEvalMode evalMode,
 			Debug.Assert(evalMode == CompoundEvalMode.EvaluatesToNewValue || IsIncrementOrDecrement(method));
 		}
 
+		/// <summary>
+		/// Gets whether <paramref name="method"/> is a static increment or decrement operator.
+		/// Whether "x++" can stand in for a call to it also depends on the target it is applied to;
+		/// see <see cref="CSharp.Resolver.CSharpResolver.IsShadowedByInstanceOperator"/>.
+		/// </summary>
 		public static bool IsIncrementOrDecrement(IMethod method, DecompilerSettings? settings = null)
 		{
 			if (!(method.IsOperator && method.IsStatic))
@@ -329,6 +338,28 @@ public static bool IsIncrementOrDecrement(IMethod method, DecompilerSettings? se
 			return false;
 		}
 
+		/// <summary>
+		/// Gets whether the variable is used as the receiver of a call to a C# 14 instance
+		/// compound assignment operator. Such a call can only be written as "x op= y" or "x++",
+		/// which requires x to be an assignable variable; a variable C# treats as read-only
+		/// (a foreach or using variable, for example) cannot take that place.
+		/// </summary>
+		public static bool IsCompoundAssignmentReceiver(ILVariable variable)
+		{
+			return variable.LoadInstructions.Concat<ILInstruction>(variable.AddressInstructions)
+				.Any(IsCompoundAssignmentReceiverUse);
+		}
+
+		/// <summary>
+		/// Gets whether the instruction is the receiver of a call to a C# 14 instance compound
+		/// assignment operator.
+		/// </summary>
+		public static bool IsCompoundAssignmentReceiverUse(ILInstruction inst)
+		{
+			return inst.Parent is CallInstruction { Method: { IsOperator: true, IsStatic: false } } call
+				&& call.Arguments.Count > 0 && call.Arguments[0] == inst;
+		}
+
 		public static bool IsStringConcat(IMethod method)
 		{
 			return method.Name == "Concat" && method.IsStatic && method.DeclaringType.IsKnownType(KnownTypeCode.String);
diff --git a/ICSharpCode.Decompiler/IL/Transforms/CopyPropagation.cs b/ICSharpCode.Decompiler/IL/Transforms/CopyPropagation.cs
index c2898ed71b..4340c9c4c5 100644
--- a/ICSharpCode.Decompiler/IL/Transforms/CopyPropagation.cs
+++ b/ICSharpCode.Decompiler/IL/Transforms/CopyPropagation.cs
@@ -89,7 +89,7 @@ static void RunOnBlock(Block block, ILTransformContext context, HashSet<ILVariab
 							context.EndStep(copiedExpr);
 						}
 					}
-					else if (v.IsSingleDefinition && CanPerformCopyPropagation(v, copiedExpr, splitVariables, context.Settings))
+					else if (v.IsSingleDefinition && CanPerformCopyPropagation(v, copiedExpr, splitVariables, context))
 					{
 						DoPropagate(v, copiedExpr, block, ref i, context);
 					}
@@ -97,7 +97,7 @@ static void RunOnBlock(Block block, ILTransformContext context, HashSet<ILVariab
 			}
 		}
 
-		static bool CanPerformCopyPropagation(ILVariable target, ILInstruction value, HashSet<ILVariable> splitVariables, DecompilerSettings settings)
+		static bool CanPerformCopyPropagation(ILVariable target, ILInstruction value, HashSet<ILVariable> splitVariables, ILTransformContext context)
 		{
 			Debug.Assert(target.StackType == value.ResultType);
 			if (target.Type.IsSmallIntegerType())
@@ -106,6 +106,10 @@ static bool CanPerformCopyPropagation(ILVariable target, ILInstruction value, Ha
 			{
 				return false; // non-local code move might change semantics when there's split variables
 			}
+			if (context.Settings.UserDefinedCompoundAssignmentOperators && CannotReplaceCompoundAssignmentReceiver(target, value, context))
+			{
+				return false;
+			}
 			switch (value.OpCode)
 			{
 				case OpCode.LdLoca:
@@ -117,7 +121,7 @@ static bool CanPerformCopyPropagation(ILVariable target, ILInstruction value, Ha
 					return true;
 				case OpCode.LdElema:
 				case OpCode.LdFlda:
-					return !settings.UseRefLocalsForAccurateOrderOfEvaluation;
+					return !context.Settings.UseRefLocalsForAccurateOrderOfEvaluation;
 				case OpCode.LdLoc:
 					var v = ((LdLoc)value).Variable;
 					if (splitVariables != null && splitVariables.Contains(v))
@@ -143,6 +147,34 @@ static bool CanPerformCopyPropagation(ILVariable target, ILInstruction value, Ha
 			}
 		}
 
+		/// <summary>
+		/// Gets whether replacing loads of <paramref name="target"/> with <paramref name="value"/>
+		/// would break a C# 14 compound assignment whose target the variable is.
+		/// </summary>
+		/// <remarks>
+		/// The receiver of an instance operator call becomes the target of "x op= y", and that form
+		/// selects its operator from the static type of x. Copying a receiver of a more derived type
+		/// over the variable would therefore pick up an operator the original call did not use, and
+		/// the cast that would prevent it cannot be an assignment target: "(Base)x op= y" is not
+		/// valid C#, whereas the variable that is about to be removed is. A read-only variable
+		/// ("this" in a class, a foreach or using variable, an "in" parameter) cannot replace a
+		/// receiver at all: it is not a valid target of "x op= y".
+		/// </remarks>
+		static bool CannotReplaceCompoundAssignmentReceiver(ILVariable target, ILInstruction value, ILTransformContext context)
+		{
+			if (value is not LdLoc)
+				return false;
+			foreach (var load in target.LoadInstructions)
+			{
+				if (load.Parent is not CallInstruction { Method: { IsOperator: true, IsStatic: false } } call
+					|| call.Arguments.Count == 0 || call.Arguments[0] != load)
+					continue;
+				if (!ILInlining.CanReplaceCompoundAssignmentReceiver(call.Method, value, context))
+					return true;
+			}
+			return false;
+		}
+
 		static void DoPropagate(ILVariable v, ILInstruction copiedExpr, Block block, ref int i, ILTransformContext context)
 		{
 			context.Step($"Copy propagate {v.Name}", copiedExpr);
diff --git a/ICSharpCode.Decompiler/IL/Transforms/FixRemainingIncrements.cs b/ICSharpCode.Decompiler/IL/Transforms/FixRemainingIncrements.cs
index 5073752a5d..0bebc2fb75 100644
--- a/ICSharpCode.Decompiler/IL/Transforms/FixRemainingIncrements.cs
+++ b/ICSharpCode.Decompiler/IL/Transforms/FixRemainingIncrements.cs
@@ -20,12 +20,25 @@
 using System.Diagnostics;
 using System.Linq;
 
+using ICSharpCode.Decompiler.CSharp.Resolver;
 using ICSharpCode.Decompiler.TypeSystem;
 
 namespace ICSharpCode.Decompiler.IL.Transforms
 {
 	public class FixRemainingIncrements : IILTransform
 	{
+		/// <summary>
+		/// Gets the type "++x" binds its operator against once the call is rewritten: the first
+		/// rewrite below increments the variable the result is stored in, whose type can be more
+		/// derived than the operator's parameter when the operator has a covariant return type.
+		/// </summary>
+		static IType GetIncrementTargetType(Call call)
+		{
+			if (call.SlotInfo == StLoc.ValueSlot && call.Parent!.SlotInfo == Block.InstructionSlot)
+				return ((StLoc)call.Parent).Variable.Type;
+			return call.GetParameter(0).Type;
+		}
+
 		void IILTransform.Run(ILFunction function, ILTransformContext context)
 		{
 			var callsToFix = new List<Call>();
@@ -35,6 +48,12 @@ void IILTransform.Run(ILFunction function, ILTransformContext context)
 					continue;
 				if (call.Arguments.Count != 1)
 					continue;
+				if (CSharpResolver.IsShadowedByInstanceOperator(call.Method,
+					GetIncrementTargetType(call), null, targetIsVariable: true, context.TypeSystem))
+				{
+					// "x++" would bind the instance operator instead of the one this call names.
+					continue;
+				}
 				if (call.Method.DeclaringType.IsKnownType(KnownTypeCode.Decimal))
 				{
 					// For decimal, legacy csc can optimize "d + 1m" to "op_Increment(d)".
diff --git a/ICSharpCode.Decompiler/IL/Transforms/ILInlining.cs b/ICSharpCode.Decompiler/IL/Transforms/ILInlining.cs
index 6c0c98c880..9171a5bc2b 100644
--- a/ICSharpCode.Decompiler/IL/Transforms/ILInlining.cs
+++ b/ICSharpCode.Decompiler/IL/Transforms/ILInlining.cs
@@ -21,6 +21,7 @@
 using System.Linq;
 using System.Reflection;
 
+using ICSharpCode.Decompiler.CSharp.Resolver;
 using ICSharpCode.Decompiler.TypeSystem;
 using ICSharpCode.Decompiler.TypeSystem.Implementation;
 
@@ -264,6 +265,12 @@ static bool DoInline(ILVariable v, ILInstruction inlinedExpression, ILInstructio
 				{
 					return false;
 				}
+				if (context.Settings.UserDefinedCompoundAssignmentOperators
+					&& UserDefinedCompoundAssign.IsCompoundAssignmentReceiverUse(loadInst)
+					&& !CanReplaceCompoundAssignmentReceiver(((CallInstruction)loadInst.Parent!).Method, inlinedExpression, context))
+				{
+					return false;
+				}
 				if (loadInst.OpCode == OpCode.LdLoca)
 				{
 					if (!IsGeneratedTemporaryForAddressOf((LdLoca)loadInst, v, inlinedExpression, options))
@@ -325,6 +332,105 @@ static bool IsStackAllocSpanConstructorArgument(ILInstruction loadInst)
 					|| newObj.Method.DeclaringType.IsKnownType(KnownTypeCode.ReadOnlySpanOfT));
 		}
 
+		/// <summary>
+		/// Gets whether <paramref name="replacement"/> can stand in for the receiver of a call to
+		/// the compound assignment operator <paramref name="op"/>. The receiver becomes the target
+		/// of "x op= y", so the replacement has to denote a storage location C# accepts there, and
+		/// it has to bind the operator the call names rather than one a more derived type brings
+		/// into scope. Shared by ILInlining and CopyPropagation, which both substitute the receiver.
+		/// </summary>
+		internal static bool CanReplaceCompoundAssignmentReceiver(IMethod op, ILInstruction replacement, ILTransformContext context)
+		{
+			if (IsReadonlyCompoundAssignmentTarget(replacement, context.Function?.Method))
+			{
+				// The target is not an assignable variable, so it cannot take the place of
+				// "x" in "x op= y"; the copy the receiver slot holds is what keeps the
+				// operator form legal.
+				return false;
+			}
+			switch (replacement.OpCode)
+			{
+				case OpCode.LdLoc:
+				case OpCode.LdObj:
+				case OpCode.LdFlda:
+				case OpCode.LdsFlda:
+					break;
+				default:
+					// anything else would turn the target into "GetX() op= y"
+					return false;
+			}
+			return !CSharpResolver.WouldRebindOperator(op,
+				GetReceiverType(replacement, context), context.TypeSystem);
+		}
+
+		/// <summary>
+		/// Gets the type that decides which operator a receiver expression binds.
+		/// </summary>
+		/// <remarks>
+		/// A stack slot standing in for a value carries whatever type the reader gave it - for a
+		/// flushed expression stack that is just the stack type, which says nothing about the
+		/// operators in play. Such a slot is a pure alias, so the value stored into it is what
+		/// really ends up as the receiver.
+		/// </remarks>
+		static IType GetReceiverType(ILInstruction expr, ILTransformContext context)
+		{
+			while (expr is LdLoc { Variable: { Kind: VariableKind.StackSlot, IsSingleDefinition: true } v }
+				&& v.StoreInstructions.SingleOrDefault() is StLoc store)
+			{
+				expr = store.Value;
+			}
+			var type = expr.InferType(context.TypeSystem);
+			// An address-taking receiver denotes the storage location itself.
+			return type is ByReferenceType byRef ? byRef.ElementType : type;
+		}
+
+		/// <summary>
+		/// Gets whether the expression denotes something C# does not accept as the target of
+		/// "x op= y". The target has to be an assignable variable even though an instance
+		/// operator never assigns to it: "this" in a class, foreach, using and fixed variables,
+		/// "in" parameters and other read-only references, and readonly fields outside the
+		/// matching constructor are all rejected by the compiler.
+		/// </summary>
+		internal static bool IsReadonlyCompoundAssignmentTarget(ILInstruction expr, IMethod contextMethod)
+		{
+			switch (expr)
+			{
+				case LdLoc { Variable: var v }:
+					return (v.IsThis() && v.Type.IsReferenceType == true)
+						|| v.IsRefReadOnly
+						|| v.Kind is VariableKind.ForeachLocal or VariableKind.UsingLocal or VariableKind.PinnedLocal;
+				case LdObj ldObj:
+					return IsReadonlyReferenceOutsideOfConstructor(ldObj.Target, contextMethod);
+				case LdFlda:
+				case LdsFlda:
+					return IsReadonlyReferenceOutsideOfConstructor(expr, contextMethod);
+				default:
+					return false;
+			}
+		}
+
+		/// <summary>
+		/// Like <see cref="IsReadonlyReference"/>, except that a readonly field still counts as
+		/// writable inside the matching constructor of its declaring type, where C# classifies
+		/// it as a variable.
+		/// </summary>
+		static bool IsReadonlyReferenceOutsideOfConstructor(ILInstruction addr, IMethod contextMethod)
+		{
+			if (!IsReadonlyReference(addr))
+				return false;
+			switch (addr)
+			{
+				case LdsFlda ldsflda:
+					return !(contextMethod is { IsConstructor: true, IsStatic: true }
+						&& ldsflda.Field.DeclaringTypeDefinition == contextMethod.DeclaringTypeDefinition);
+				case LdFlda ldflda when ldflda.Field.IsReadOnly && ldflda.Target.MatchLdThis():
+					return !(contextMethod is { IsConstructor: true, IsStatic: false }
+						&& ldflda.Field.DeclaringTypeDefinition == contextMethod.DeclaringTypeDefinition);
+				default:
+					return true;
+			}
+		}
+
 		/// <summary>
 		/// Is this a temporary variable generated by the C# compiler for instance method calls on value type values
 		/// </summary>
diff --git a/ICSharpCode.Decompiler/IL/Transforms/TransformAssignment.cs b/ICSharpCode.Decompiler/IL/Transforms/TransformAssignment.cs
index 8edba814aa..52bfd58eea 100644
--- a/ICSharpCode.Decompiler/IL/Transforms/TransformAssignment.cs
+++ b/ICSharpCode.Decompiler/IL/Transforms/TransformAssignment.cs
@@ -22,6 +22,7 @@
 using System.Linq.Expressions;
 
 using ICSharpCode.Decompiler.CSharp;
+using ICSharpCode.Decompiler.CSharp.Resolver;
 using ICSharpCode.Decompiler.TypeSystem;
 using ICSharpCode.Decompiler.Util;
 
@@ -386,18 +387,20 @@ internal static bool HandleCompoundAssign(ILInstruction compoundStore, Statement
 					binary, target, targetKind, binary.Right,
 					targetType, CompoundEvalMode.EvaluatesToNewValue);
 			}
-			else if (setterValue is Call operatorCall && operatorCall.Method.IsOperator)
+			else if (setterValue is Call operatorCall && operatorCall.Method.IsOperator && operatorCall.Method.IsStatic)
 			{
 				if (operatorCall.Arguments.Count == 0)
 					return false;
 				if (!IsMatchingCompoundLoad(operatorCall.Arguments[0], compoundStore, out var target, out var targetKind, out var finalizeMatch, forbiddenVariable: storeInSetter?.Variable))
 					return false;
 				ILInstruction rhs;
+				IType valueType;
 				if (operatorCall.Arguments.Count == 2)
 				{
 					if (CSharp.ExpressionBuilder.GetAssignmentOperatorTypeFromMetadataName(operatorCall.Method.Name, context.Settings) == null)
 						return false;
 					rhs = operatorCall.Arguments[1];
+					valueType = operatorCall.GetParameter(1).Type;
 				}
 				else if (operatorCall.Arguments.Count == 1)
 				{
@@ -405,11 +408,19 @@ internal static bool HandleCompoundAssign(ILInstruction compoundStore, Statement
 						return false;
 					// use a dummy node so that we don't need a dedicated instruction for user-defined unary operator calls
 					rhs = new LdcI4(1);
+					valueType = null;
 				}
 				else
 				{
 					return false;
 				}
+				// IsCompoundStore accepts a store to a local (StLoc) or to a field, array element,
+				// ref or pointer (StObj), which are variables, and a setter call, which is not.
+				if (CSharpResolver.IsShadowedByInstanceOperator(operatorCall.Method, targetType, valueType,
+					targetIsVariable: compoundStore is not CallInstruction, context.TypeSystem))
+				{
+					return false;
+				}
 				if (operatorCall.IsLifted)
 					return false; // TODO: add tests and think about whether nullables need special considerations
 				context.Step($"Compound assignment (user-defined binary)", compoundStore);
@@ -892,6 +903,11 @@ bool TransformPreIncDecOperatorWithInlineStore(Block block, int pos)
 			{
 				if (!(operatorCall.Method.Name == "op_Increment" || operatorCall.Method.Name == "op_Decrement"))
 					return false;
+				if (CSharpResolver.IsShadowedByInstanceOperator(operatorCall.Method, targetType, null,
+					targetIsVariable: true, context.TypeSystem))
+				{
+					return false;
+				}
 				if (operatorCall.IsLifted)
 					return false; // TODO: add tests and think about whether nullables need special considerations
 				ldloc = operatorCall.Arguments[0] as LdLoc;
@@ -977,6 +993,10 @@ bool TransformPostIncDecOperatorWithInlineStore(Block block, int pos)
 			{
 				if (!(operatorCall.Method.Name == "op_Increment" || operatorCall.Method.Name == "op_Decrement"))
 					return false;
+				// No check for an instance operator of the same name here, unlike the prefix form:
+				// a postfix increment whose result is used cannot bind to one. An operator that
+				// mutates the instance in place has no way to hand back the value from before it
+				// ran, so C# only ever considers the static operator for that shape.
 				if (operatorCall.IsLifted)
 					return false; // TODO: add tests and think about whether nullables need special considerations
 				stloc = operatorCall.Arguments[0] as StLoc;
@@ -1088,6 +1108,9 @@ bool TransformPostIncDecOperator(Block block, int i)
 			{
 				if (!operatorCall.Arguments[0].MatchLdLoc(tmpVar))
 					return false;
+				// No shadowing check here: "x++" whose result is used hands back the value from
+				// before the increment, which an instance operator mutating in place cannot
+				// produce, so C# does not consider one for that shape.
 				if (!UserDefinedCompoundAssign.IsIncrementOrDecrement(operatorCall.Method, context.Settings))
 					return false;
 				if (operatorCall.IsLifted)
diff --git a/ICSharpCode.Decompiler/IL/Transforms/UsingTransform.cs b/ICSharpCode.Decompiler/IL/Transforms/UsingTransform.cs
index 39c20c13f5..522c1343ab 100644
--- a/ICSharpCode.Decompiler/IL/Transforms/UsingTransform.cs
+++ b/ICSharpCode.Decompiler/IL/Transforms/UsingTransform.cs
@@ -97,6 +97,9 @@ bool TransformUsing(Block block, int i)
 				return false;
 			if (!MatchDisposeBlock(container, storeInst.Variable, storeInst.Value.MatchLdNull()))
 				return false;
+			if (tryFinally.TryBlock is not BlockContainer tryBody
+				|| !RedirectCompoundAssignmentReceivers(storeInst.Variable, tryBody.EntryPoint, 0))
+				return false;
 			context.Step("UsingTransform", tryFinally);
 			storeInst.Variable.Kind = VariableKind.UsingLocal;
 			block.Instructions.RemoveAt(i + 1);
@@ -166,6 +169,8 @@ bool TransformUsingVB(Block block, int i)
 				return false;
 			if (!(tryFinally.FinallyBlock is BlockContainer container) || !MatchDisposeBlock(container, storeInst.Variable, storeInst.Value.MatchLdNull()))
 				return false;
+			if (!RedirectCompoundAssignmentReceivers(storeInst.Variable, tryContainer.EntryPoint, 1))
+				return false;
 			context.Step("UsingTransformVB", tryFinally);
 			storeInst.Variable.Kind = VariableKind.UsingLocal;
 			tryContainer.EntryPoint.Instructions.RemoveAt(0);
@@ -175,6 +180,32 @@ bool TransformUsingVB(Block block, int i)
 			return true;
 		}
 
+		/// <summary>
+		/// A using variable is read-only, so an instance compound assignment operator can only be
+		/// applied to a copy of it, which the compiler may have optimized away. The loads that serve
+		/// as operator receivers are redirected to a fresh copy stored at the start of the using
+		/// body. An address receiver (a value type mutated in place) cannot be redirected without
+		/// changing what is mutated, so no using statement is introduced for it.
+		/// </summary>
+		/// <returns>false if the using statement must not be introduced.</returns>
+		bool RedirectCompoundAssignmentReceivers(ILVariable variable, Block usingBody, int insertionIndex)
+		{
+			if (!context.Settings.UserDefinedCompoundAssignmentOperators)
+				return true;
+			if (variable.AddressInstructions.Any(UserDefinedCompoundAssign.IsCompoundAssignmentReceiverUse))
+				return false;
+			var receiverLoads = variable.LoadInstructions.Where(UserDefinedCompoundAssign.IsCompoundAssignmentReceiverUse).ToArray();
+			if (receiverLoads.Length == 0)
+				return true;
+			var copy = context.Function.RegisterVariable(VariableKind.Local, variable.Type);
+			foreach (var load in receiverLoads)
+			{
+				load.ReplaceWith(new LdLoc(copy));
+			}
+			usingBody.Instructions.Insert(insertionIndex, new StLoc(copy, new LdLoc(variable)));
+			return true;
+		}
+
 		bool CheckResourceType(IType type)
 		{
 			// non-generic IEnumerator does not implement IDisposable.
@@ -501,6 +532,9 @@ private bool TransformAsyncUsing(Block block, int i)
 				return false;
 			if (!(tryFinally.FinallyBlock is BlockContainer container) || !MatchDisposeBlock(container, storeInst.Variable, usingNull: false, disposeMethodFullName, KnownTypeCode.IAsyncDisposable))
 				return false;
+			if (tryFinally.TryBlock is not BlockContainer asyncTryBody
+				|| !RedirectCompoundAssignmentReceivers(storeInst.Variable, asyncTryBody.EntryPoint, 0))
+				return false;
 			context.Step("AsyncUsingTransform", tryFinally);
 			storeInst.Variable.Kind = VariableKind.UsingLocal;
 			block.Instructions.RemoveAt(i);
diff --git a/ICSharpCode.Decompiler/Output/IAmbience.cs b/ICSharpCode.Decompiler/Output/IAmbience.cs
index f88a8576e3..aec5ff0e7a 100644
--- a/ICSharpCode.Decompiler/Output/IAmbience.cs
+++ b/ICSharpCode.Decompiler/Output/IAmbience.cs
@@ -125,6 +125,10 @@ public enum ConversionFlags
 		/// Support C# 14 <c>extension</c> declarations.
 		/// </summary>
 		SupportExtensionDeclarations = 0x400000,
+		/// <summary>
+		/// Support C# 14 user-defined compound assignment operators (<c>operator +=</c>).
+		/// </summary>
+		SupportUserDefinedCompoundAssignmentOperators = 0x800000,
 
 		StandardConversionFlags = ShowParameterNames |
 			ShowAccessibility |
@@ -140,7 +144,7 @@ public enum ConversionFlags
 			ShowDefinitionKeyword |
 			ShowBody,
 
-		All = 0x1fffff,
+		All = 0xffffff,
 	}
 
 	/// <summary>
diff --git a/ICSharpCode.Decompiler/TypeSystem/DecompilerTypeSystem.cs b/ICSharpCode.Decompiler/TypeSystem/DecompilerTypeSystem.cs
index f641da40a1..72c18d8ccd 100644
--- a/ICSharpCode.Decompiler/TypeSystem/DecompilerTypeSystem.cs
+++ b/ICSharpCode.Decompiler/TypeSystem/DecompilerTypeSystem.cs
@@ -159,13 +159,20 @@ public enum TypeSystemOptions
 		/// </summary>
 		RuntimeAsync = 0x100000,
 		/// <summary>
+		/// If this option is active, a void-returning instance method whose name is one of the C# 14
+		/// compound assignment operators (op_AdditionAssignment, op_IncrementAssignment, ...) is
+		/// classified as an operator. Without it such a method stays a plain method, so it keeps its
+		/// metadata name and its specialname flag surfaces as a [SpecialName] attribute.
+		/// </summary>
+		UserDefinedCompoundAssignmentOperators = 0x200000,
+		/// <summary>
 		/// Default settings: typical options for the decompiler, with all C# language features enabled.
 		/// </summary>
 		Default = Dynamic | Tuple | ExtensionMethods | DecimalConstants | ReadOnlyStructsAndParameters
 			| RefStructs | UnmanagedConstraints | NullabilityAnnotations | ReadOnlyMethods
 			| NativeIntegers | FunctionPointers | ScopedRef | NativeIntegersWithoutAttribute
 			| RefReadOnlyParameters | ParamsCollections | FirstClassSpanTypes | ExtensionMembers
-			| RuntimeAsync
+			| RuntimeAsync | UserDefinedCompoundAssignmentOperators
 	}
 
 	/// <summary>
@@ -215,6 +222,8 @@ public static TypeSystemOptions GetOptions(DecompilerSettings settings)
 				typeSystemOptions |= TypeSystemOptions.ExtensionMembers;
 			if (settings.AsyncAwait)
 				typeSystemOptions |= TypeSystemOptions.RuntimeAsync;
+			if (settings.UserDefinedCompoundAssignmentOperators)
+				typeSystemOptions |= TypeSystemOptions.UserDefinedCompoundAssignmentOperators;
 			return typeSystemOptions;
 		}
 
diff --git a/ICSharpCode.Decompiler/TypeSystem/Implementation/AttributeListBuilder.cs b/ICSharpCode.Decompiler/TypeSystem/Implementation/AttributeListBuilder.cs
index 8f6e8f06be..eaa046c402 100644
--- a/ICSharpCode.Decompiler/TypeSystem/Implementation/AttributeListBuilder.cs
+++ b/ICSharpCode.Decompiler/TypeSystem/Implementation/AttributeListBuilder.cs
@@ -234,6 +234,7 @@ internal bool IgnoreAttribute(TopLevelTypeName attributeType, SymbolKind target)
 									return (options & TypeSystemOptions.ReadOnlyStructsAndParameters) != 0;
 								case SymbolKind.Method:
 								case SymbolKind.Accessor:
+								case SymbolKind.Operator:
 									return (options & TypeSystemOptions.ReadOnlyMethods) != 0;
 								case SymbolKind.ReturnType:
 								case SymbolKind.Property:
diff --git a/ICSharpCode.Decompiler/TypeSystem/Implementation/MetadataMethod.cs b/ICSharpCode.Decompiler/TypeSystem/Implementation/MetadataMethod.cs
index 1f69799d07..c2f54ed6b4 100644
--- a/ICSharpCode.Decompiler/TypeSystem/Implementation/MetadataMethod.cs
+++ b/ICSharpCode.Decompiler/TypeSystem/Implementation/MetadataMethod.cs
@@ -83,7 +83,8 @@ internal MetadataMethod(MetadataModule module, MethodDefinitionHandle handle)
 					this.symbolKind = SymbolKind.Constructor;
 				}
 				else if (name.StartsWith("op_", StringComparison.Ordinal)
-					&& CSharp.Syntax.OperatorDeclaration.GetOperatorType(name) != null)
+					&& CSharp.Syntax.OperatorDeclaration.GetOperatorType(name) is CSharp.Syntax.OperatorType operatorType
+					&& (!CSharp.Syntax.OperatorDeclaration.IsCompoundAssignment(operatorType) || IsUserDefinedCompoundAssignmentOperator(operatorType)))
 				{
 					this.symbolKind = SymbolKind.Operator;
 				}
@@ -96,7 +97,7 @@ internal MetadataMethod(MetadataModule module, MethodDefinitionHandle handle)
 					this.symbolKind = SymbolKind.Destructor;
 				}
 			}
-			else if ((attributes & MethodAttributes.Static) != 0 && typeParameters.Length == 0)
+			else if (typeParameters.Length == 0)
 			{
 				// Operators that are explicit interface implementations are not marked
 				// with MethodAttributes.SpecialName or MethodAttributes.RTSpecialName
@@ -107,7 +108,10 @@ internal MetadataMethod(MetadataModule module, MethodDefinitionHandle handle)
 					name = name.Substring(index + 1);
 
 					if (name.StartsWith("op_", StringComparison.Ordinal)
-						&& CSharp.Syntax.OperatorDeclaration.GetOperatorType(name) != null)
+						&& CSharp.Syntax.OperatorDeclaration.GetOperatorType(name) is CSharp.Syntax.OperatorType operatorType
+						&& (CSharp.Syntax.OperatorDeclaration.IsCompoundAssignment(operatorType)
+							? IsUserDefinedCompoundAssignmentOperator(operatorType)
+							: (attributes & MethodAttributes.Static) != 0))
 					{
 						this.symbolKind = SymbolKind.Operator;
 					}
@@ -118,6 +122,53 @@ internal MetadataMethod(MetadataModule module, MethodDefinitionHandle handle)
 				&& def.GetCustomAttributes().HasKnownAttribute(metadata, KnownAttribute.Extension);
 		}
 
+		/// <summary>
+		/// Gets whether this method has the shape C# requires of a user-defined compound assignment
+		/// operator: an instance method returning void, taking one parameter (none for the
+		/// increment and decrement operators). Other languages give unrelated methods the same
+		/// metadata names: F# mangles
+		/// "static member (+=)" to a static, value-returning op_AdditionAssignment, and C++/CLI emits
+		/// value-returning instance operators. Those are plain methods as far as C# is concerned.
+		/// </summary>
+		/// <summary>
+		/// Gets whether this method should be classified as a C# 14 user-defined compound assignment
+		/// operator: the feature has to be enabled (<see cref="TypeSystemOptions.UserDefinedCompoundAssignmentOperators"/>)
+		/// and the method has to have the required shape. When the feature is off the method stays a
+		/// plain method, so it keeps its op_*Assignment name and its specialname flag is surfaced.
+		/// </summary>
+		bool IsUserDefinedCompoundAssignmentOperator(CSharp.Syntax.OperatorType operatorType)
+		{
+			return (module.TypeSystemOptions & TypeSystemOptions.UserDefinedCompoundAssignmentOperators) != 0
+				&& IsCompoundAssignmentOperatorSignature(operatorType);
+		}
+
+		bool IsCompoundAssignmentOperatorSignature(CSharp.Syntax.OperatorType operatorType)
+		{
+			if ((attributes & MethodAttributes.Static) != 0 || !ReturnType.IsKnownType(KnownTypeCode.Void))
+				return false;
+			// a static class cannot contain operators
+			if (DeclaringTypeDefinition is { IsAbstract: true, IsSealed: true })
+				return false;
+			int parameterCount = operatorType
+				is CSharp.Syntax.OperatorType.IncrementAssignment
+				or CSharp.Syntax.OperatorType.CheckedIncrementAssignment
+				or CSharp.Syntax.OperatorType.DecrementAssignment
+				or CSharp.Syntax.OperatorType.CheckedDecrementAssignment
+				? 0 : 1;
+			if (Parameters.Count != parameterCount)
+				return false;
+			if (parameterCount == 1)
+			{
+				// C# allows only value, "in" and "ref readonly" parameters on operators
+				IParameter parameter = Parameters[0];
+				if (parameter.ReferenceKind is not (ReferenceKind.None or ReferenceKind.In or ReferenceKind.RefReadOnly))
+					return false;
+				if (parameter.IsParams)
+					return false;
+			}
+			return true;
+		}
+
 		public EntityHandle MetadataToken => handle;
 
 		public override string ToString()
diff --git a/ICSharpCode.ILSpyCmd/IlspyCmdProgram.cs b/ICSharpCode.ILSpyCmd/IlspyCmdProgram.cs
index 4932aa375c..c3edd58c36 100644
--- a/ICSharpCode.ILSpyCmd/IlspyCmdProgram.cs
+++ b/ICSharpCode.ILSpyCmd/IlspyCmdProgram.cs
@@ -160,7 +160,7 @@ class ILSpyCmdProgram
 
 		[Option("-lv|--languageversion <version>", "C# Language version: CSharp1, CSharp2, CSharp3, " +
 			"CSharp4, CSharp5, CSharp6, CSharp7, CSharp7_1, CSharp7_2, CSharp7_3, CSharp8_0, CSharp9_0, " +
-			"CSharp10_0, CSharp11_0, CSharp12_0, CSharp13_0, Preview or Latest", CommandOptionType.SingleValue)]
+			"CSharp10_0, CSharp11_0, CSharp12_0, CSharp13_0, CSharp14_0, CSharp15_0, Preview or Latest", CommandOptionType.SingleValue)]
 		public LanguageVersion LanguageVersion { get; } = LanguageVersion.Latest;
 
 		[FileExists]
diff --git a/ILSpy/Languages/CSharpLanguage.cs b/ILSpy/Languages/CSharpLanguage.cs
index 2be32de77d..1bf0bfc2a3 100644
--- a/ILSpy/Languages/CSharpLanguage.cs
+++ b/ILSpy/Languages/CSharpLanguage.cs
@@ -86,7 +86,9 @@ public sealed partial class CSharpLanguage : Language
 		};
 
 		static CSharpAmbience CreateAmbience() => new() {
-			ConversionFlags = ConversionFlags.ShowTypeParameterList | ConversionFlags.PlaceReturnTypeAfterParameterList,
+			ConversionFlags = ConversionFlags.ShowTypeParameterList | ConversionFlags.PlaceReturnTypeAfterParameterList
+				| ConversionFlags.SupportOperatorChecked | ConversionFlags.SupportUnsignedRightShift
+				| ConversionFlags.SupportUserDefinedCompoundAssignmentOperators,
 		};
 
 		public override string TypeToString(IType type, ConversionFlags conversionFlags = ConversionFlags.UseFullyQualifiedEntityNames | ConversionFlags.UseFullyQualifiedTypeNames)
diff --git a/ILSpy/Properties/Resources.resx b/ILSpy/Properties/Resources.resx
index f65ae29f58..9782fb6dd9 100644
--- a/ILSpy/Properties/Resources.resx
+++ b/ILSpy/Properties/Resources.resx
@@ -654,6 +654,9 @@ Are you sure you want to continue?</value>
   <data name="DecompilerSettings.UseVariableNamesFromDebugSymbolsIfAvailable" xml:space="preserve">
     <value>Use variable names from debug symbols, if available</value>
   </data>
+  <data name="DecompilerSettings.UserDefinedCompoundAssignmentOperators" xml:space="preserve">
+    <value>User-defined compound assignment operators</value>
+  </data>
   <data name="DecompilerSettings.Utf8StringLiterals" xml:space="preserve">
     <value>UTF-8 string literals</value>
   </data>