From 229158665939f66550e26e102bb22d69fa261eb9 Mon Sep 17 00:00:00 2001
From: Siegfried Pammer <siegfriedpammer@gmail.com>
Date: Fri, 28 Aug 2026 22:45:10 +0200
Subject: [PATCH 1/7] Classify C# 14 user-defined compound assignment operators
 in the type system

C# 14 lets a type declare "void operator +=(T)" and friends: void-returning
instance methods under the op_*Assignment metadata names. Only that exact shape
becomes SymbolKind.Operator, and only while the new setting is on, because other
languages use the same names for unrelated methods: F# mangles
"static member (+=)" to a static, value-returning op_AdditionAssignment, and
C++/CLI emits value-returning instance operators. Those, and every method when
the setting is off, stay plain methods with a surfaced [SpecialName].

Assisted-by: Claude:claude-opus-5:Claude Code
---
 .../ICSharpCode.Decompiler.Tests.csproj       |  2 +
 ...nedCompoundAssignmentOperators.Expected.cs | 49 +++++++++++++++
 ...oUserDefinedCompoundAssignmentOperators.cs | 60 ++++++++++++++++++
 .../UglyTestRunner.cs                         |  8 +++
 .../Syntax/TypeMembers/OperatorDeclaration.cs | 62 ++++++++++++++++++-
 ICSharpCode.Decompiler/DecompilerSettings.cs  |  7 +++
 .../TypeSystem/DecompilerTypeSystem.cs        | 11 +++-
 .../Implementation/AttributeListBuilder.cs    |  1 +
 .../Implementation/MetadataMethod.cs          | 57 ++++++++++++++++-
 ILSpy/Properties/Resources.resx               |  3 +
 10 files changed, 254 insertions(+), 6 deletions(-)
 create mode 100644 ICSharpCode.Decompiler.Tests/TestCases/Ugly/NoUserDefinedCompoundAssignmentOperators.Expected.cs
 create mode 100644 ICSharpCode.Decompiler.Tests/TestCases/Ugly/NoUserDefinedCompoundAssignmentOperators.cs

diff --git a/ICSharpCode.Decompiler.Tests/ICSharpCode.Decompiler.Tests.csproj b/ICSharpCode.Decompiler.Tests/ICSharpCode.Decompiler.Tests.csproj
index 714454f75b..af25b88276 100644
--- a/ICSharpCode.Decompiler.Tests/ICSharpCode.Decompiler.Tests.csproj
+++ b/ICSharpCode.Decompiler.Tests/ICSharpCode.Decompiler.Tests.csproj
@@ -280,6 +280,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/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/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/DecompilerSettings.cs b/ICSharpCode.Decompiler/DecompilerSettings.cs
index 3a5f0537b5..0e9139aa9a 100644
--- a/ICSharpCode.Decompiler/DecompilerSettings.cs
+++ b/ICSharpCode.Decompiler/DecompilerSettings.cs
@@ -870,6 +870,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/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..d061b7305d 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 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);
+		}
+
+		/// <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>
+		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/ILSpy/Properties/Resources.resx b/ILSpy/Properties/Resources.resx
index 73d84bc0df..36edf8f8f0 100644
--- a/ILSpy/Properties/Resources.resx
+++ b/ILSpy/Properties/Resources.resx
@@ -657,6 +657,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>

From 3ff2d0f1087c98e572ec2128b6c1f6bb17bcc5cd Mon Sep 17 00:00:00 2001
From: Siegfried Pammer <siegfriedpammer@gmail.com>
Date: Fri, 28 Aug 2026 22:46:02 +0200
Subject: [PATCH 2/7] Keep the receiver of an instance compound assignment
 operator a variable

An instance compound assignment operator has no callable spelling: its call
sites can only be written as "x op= y" or "x++", and C# requires x to be an
assignable variable whose static type binds the operator the call names. The
reader therefore parks an object-typed receiver in a stack slot typed with the
operator's declaring type, and the passes that would substitute or retype such
a receiver hold back. CallInstruction vetoes unfit receiver replacements
through SatisfiesSlotRestrictionForInlining - not writable, not a storage
location, or of a type that declares a hiding operator of the same name or its
checked/unchecked sibling (a declaration-existence check on the type system,
deliberately not a binding question) - which covers inlining; copy propagation
asks the same check per receiver load, the using-transform hands receiver
loads a writable copy of the read-only using variable, and stack slots that
were typed on purpose keep their type when translated.

Assisted-by: Claude:claude-opus-5:Claude Code
---
 .../CSharp/ExpressionBuilder.cs               |  15 ++-
 ICSharpCode.Decompiler/IL/ILReader.cs         |  33 ++++-
 .../IL/Instructions/CallInstruction.cs        | 115 ++++++++++++++++++
 .../CompoundAssignmentInstruction.cs          |  43 +++++++
 .../IL/Transforms/CopyPropagation.cs          |  38 +++++-
 .../IL/Transforms/ILInlining.cs               |  47 +++++++
 .../IL/Transforms/UsingTransform.cs           |  34 ++++++
 7 files changed, 316 insertions(+), 9 deletions(-)

diff --git a/ICSharpCode.Decompiler/CSharp/ExpressionBuilder.cs b/ICSharpCode.Decompiler/CSharp/ExpressionBuilder.cs
index 2040832f5c..33601144af 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/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/CallInstruction.cs b/ICSharpCode.Decompiler/IL/Instructions/CallInstruction.cs
index 3aa46e16e7..ff2cfc82b4 100644
--- a/ICSharpCode.Decompiler/IL/Instructions/CallInstruction.cs
+++ b/ICSharpCode.Decompiler/IL/Instructions/CallInstruction.cs
@@ -19,6 +19,7 @@
 
 using System;
 using System.Diagnostics;
+using System.Linq;
 
 using ICSharpCode.Decompiler.TypeSystem;
 
@@ -169,6 +170,119 @@ protected internal sealed override bool PerformMatch(ILInstruction? other, ref P
 				&& object.Equals(this.ConstrainedTo, o.ConstrainedTo)
 				&& Patterns.ListMatch.DoMatch(this.Arguments, o.Arguments, ref match);
 		}
+
+		internal override bool SatisfiesSlotRestrictionForInlining(int childIndex, ILInstruction newChild)
+		{
+			// The receiver of a call to a C# 14 instance compound assignment operator becomes the
+			// target of "x op= y", so the expression taking its place has to be one C# accepts
+			// there and one that still binds the operator this call names. Classification already
+			// implies the corresponding decompiler setting is on.
+			if (childIndex == 0 && Method.IsOperator && !Method.IsStatic
+				&& !CanBeCompoundAssignmentReceiver(newChild))
+			{
+				return false;
+			}
+			return base.SatisfiesSlotRestrictionForInlining(childIndex, newChild);
+		}
+
+		/// <summary>
+		/// Gets whether <paramref name="replacement"/> can stand in for the receiver of this call
+		/// to an instance compound assignment operator. 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. Consulted by inlining through the slot restriction above, and by copy
+		/// propagation, which substitutes receivers the same way.
+		/// </summary>
+		internal bool CanBeCompoundAssignmentReceiver(ILInstruction replacement)
+		{
+			var contextMethod = this.Ancestors.OfType<ILFunction>().FirstOrDefault()?.Method;
+			if (Transforms.ILInlining.IsReadonlyCompoundAssignmentTarget(replacement, contextMethod))
+			{
+				// 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 !ReplacementMayRebindOperator(Method, GetReceiverType(replacement));
+		}
+
+		/// <summary>
+		/// Gets whether "x op= y" with x of type <paramref name="receiverType"/> could bind an
+		/// operator other than <paramref name="op"/>, the one the call being rewritten names.
+		/// The form selects its operator from the static type of x, so an operator introduced
+		/// anywhere between that type and the type declaring <paramref name="op"/> can take the
+		/// call. This is a declaration-existence check, deliberately one-sided: overloads next to
+		/// the operator itself cannot be selected by the receiver's type, and an override of a
+		/// virtual operator occupies the slot of the operator the call names. Where it errs it
+		/// only refuses a substitution, which costs a local copy in the output, never its
+		/// correctness. The exact form of the question, argument applicability included, is
+		/// CSharpResolver.WouldRebindOperator, which the C# transforms use; this check stays
+		/// approximate because the IL layer does not bind.
+		/// </summary>
+		static bool ReplacementMayRebindOperator(IMethod op, IType receiverType)
+		{
+			if (op.DeclaringType.Kind == TypeKind.Interface)
+			{
+				// 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. System.Object stays permissive - it is the stack-type placeholder
+				// several ILAst nodes carry.
+				return receiverType.Kind is not (TypeKind.Interface or TypeKind.TypeParameter)
+					&& !receiverType.IsKnownType(KnownTypeCode.Object);
+			}
+			// Both the checked and the unchecked operator can take the call: which of them applies
+			// depends on the checked context the assignment ends up in.
+			string siblingName = UserDefinedCompoundAssign.GetCheckedSiblingName(op.Name);
+			foreach (var type in receiverType.GetAllBaseTypeDefinitions())
+			{
+				if (type == op.DeclaringTypeDefinition)
+					continue;
+				if (!type.GetAllBaseTypeDefinitions().Contains(op.DeclaringTypeDefinition))
+					continue;
+				foreach (var m in type.Methods)
+				{
+					if (m.IsOperator && !m.IsStatic && !m.IsOverride
+						&& m.Accessibility == Accessibility.Public
+						&& (m.Name == op.Name || m.Name == siblingName))
+					{
+						return true;
+					}
+				}
+			}
+			return false;
+		}
+
+		/// <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>
+		IType GetReceiverType(ILInstruction expr)
+		{
+			while (expr is LdLoc { Variable: { Kind: VariableKind.StackSlot, IsSingleDefinition: true } v }
+				&& v.StoreInstructions.SingleOrDefault() is StLoc store)
+			{
+				expr = store.Value;
+			}
+			var type = expr.InferType(Method.Compilation);
+			// An address-taking receiver denotes the storage location itself.
+			return type is ByReferenceType byRef ? byRef.ElementType : type;
+		}
 	}
 
 	partial class Call : ILiftableInstruction
@@ -188,5 +302,6 @@ public StackType UnderlyingResultType {
 					return Method.ReturnType.GetStackType();
 			}
 		}
+
 	}
 }
diff --git a/ICSharpCode.Decompiler/IL/Instructions/CompoundAssignmentInstruction.cs b/ICSharpCode.Decompiler/IL/Instructions/CompoundAssignmentInstruction.cs
index 85f49aad6e..de8c72c9c6 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: the statement form binds a C# 14 instance operator on the target's type first.
+		/// </summary>
 		public static bool IsIncrementOrDecrement(IMethod method, DecompilerSettings? settings = null)
 		{
 			if (!(method.IsOperator && method.IsStatic))
@@ -329,6 +338,40 @@ 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 the metadata name of the checked operator paired with an unchecked one, and vice
+		/// versa. Which of the two "x op= y" binds depends on the checked context the assignment
+		/// ends up in, so code reasoning about that form has to consider the pair together.
+		/// </summary>
+		public static string GetCheckedSiblingName(string operatorName)
+		{
+			return operatorName.StartsWith("op_Checked", StringComparison.Ordinal)
+				? "op_" + operatorName.Substring("op_Checked".Length)
+				: "op_Checked" + operatorName.Substring("op_".Length);
+		}
+
+		/// <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..8744f24490 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 (CannotReplaceCompoundAssignmentReceiver(target, value))
+			{
+				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)
+		{
+			if (value is not LdLoc)
+				return false;
+			foreach (var load in target.LoadInstructions)
+			{
+				if (!UserDefinedCompoundAssign.IsCompoundAssignmentReceiverUse(load))
+					continue;
+				var call = (CallInstruction)load.Parent!;
+				if (!call.CanBeCompoundAssignmentReceiver(value))
+					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/ILInlining.cs b/ICSharpCode.Decompiler/IL/Transforms/ILInlining.cs
index 6c0c98c880..efe95449e9 100644
--- a/ICSharpCode.Decompiler/IL/Transforms/ILInlining.cs
+++ b/ICSharpCode.Decompiler/IL/Transforms/ILInlining.cs
@@ -325,6 +325,53 @@ static bool IsStackAllocSpanConstructorArgument(ILInstruction loadInst)
 					|| newObj.Method.DeclaringType.IsKnownType(KnownTypeCode.ReadOnlySpanOfT));
 		}
 
+		/// <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/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);

From d41032efbe382de2a1eb0a49854d0e797b836b1d Mon Sep 17 00:00:00 2001
From: Siegfried Pammer <siegfriedpammer@gmail.com>
Date: Sat, 29 Aug 2026 06:46:05 +0200
Subject: [PATCH 3/7] Bind instance compound assignment operators when building
 expressions

"x op= y" and a prefix increment resolve in two phases: the instance operators
reachable from the static type of x come first wherever x is a variable -
whether or not the result is used - and the static operators only if none of
them is applicable. A postfix increment whose result is used is the one form
that always binds a static operator. CallBuilder models the first phase when it
checks that recompiling an instance operator call binds the same method; the
fallback phase is deliberately not modeled, since a call the instance
candidates cannot account for must give up the operator form rather than
collide with a static operator.

The same rule cuts the other way for the folds built from static operator
calls: a shadowed fold has to be written in one of the static-binding forms.
The binary operators become "x = x + y"; an increment becomes a postfix
increment whose result goes to a discard, "_ = x++;". That form only exists as
a statement, so the folds that would embed a shadowed increment in an
expression hold back and FixRemainingIncrements gives the increment a statement
of its own instead. A foreach variable cannot be such a receiver at all (it is
read-only), so the loop keeps the existing variable as a writable copy, both
for a plain loop variable and for a deconstruction.

Assisted-by: Claude:claude-opus-5:Claude Code
---
 ICSharpCode.Decompiler/CSharp/CallBuilder.cs  |  19 +-
 .../CSharp/ExpressionBuilder.cs               |  74 ++++++++
 .../CSharp/Resolver/CSharpResolver.cs         | 176 ++++++++++++++++++
 .../CSharp/StatementBuilder.cs                |  51 ++++-
 .../ReplaceMethodCallsWithOperators.cs        |   2 +-
 .../IL/Transforms/FixRemainingIncrements.cs   |  19 +-
 .../IL/Transforms/TransformAssignment.cs      |  21 +++
 7 files changed, 353 insertions(+), 9 deletions(-)

diff --git a/ICSharpCode.Decompiler/CSharp/CallBuilder.cs b/ICSharpCode.Decompiler/CSharp/CallBuilder.cs
index d4cb8e0900..aa88ffe41a 100644
--- a/ICSharpCode.Decompiler/CSharp/CallBuilder.cs
+++ b/ICSharpCode.Decompiler/CSharp/CallBuilder.cs
@@ -1667,7 +1667,7 @@ OverloadResolutionErrors IsUnambiguousCall(ExpectedTargetDetails expectedTargetD
 					}
 				}
 			}
-			else if (method.IsOperator)
+			else if (method.IsOperator && method.IsStatic)
 			{
 				IEnumerable<IParameterizedMember> operatorCandidates;
 				if (arguments.Length == 1)
@@ -1703,6 +1703,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 modeled: 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 resolver.GetInstanceOperatorCandidates(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 33601144af..facc6270c5 100644
--- a/ICSharpCode.Decompiler/CSharp/ExpressionBuilder.cs
+++ b/ICSharpCode.Decompiler/CSharp/ExpressionBuilder.cs
@@ -2012,6 +2012,16 @@ protected internal override TranslatedExpression VisitUserDefinedCompoundAssign(
 			{
 				target = Translate(inst.Target, loadType);
 			}
+			if (settings.UserDefinedCompoundAssignmentOperators
+				&& (inst.Method.Parameters.Count == 2 || inst.SlotInfo == Block.InstructionSlot)
+				&& inst.TargetKind != CompoundTargetKind.Property
+				&& inst.Method.IsOperator
+				&& resolver.IsShadowedByInstanceOperator(inst.Method, target.ResolveResult.Type,
+					inst.Method.Parameters.Count == 2 ? inst.Method.Parameters[1].Type : null,
+					targetIsVariable: true))
+			{
+				return TranslateShadowedCompoundAssign(inst, target);
+			}
 			var opType = OperatorDeclaration.GetOperatorType(inst.Method.Name);
 			if (opType != null && OperatorDeclaration.IsChecked(opType.Value))
 			{
@@ -2064,6 +2074,70 @@ protected internal override TranslatedExpression VisitUserDefinedCompoundAssign(
 			}
 		}
 
+		/// <summary>
+		/// Writes a compound assignment whose usual spelling would bind a C# 14 instance operator
+		/// instead of the static operator this instruction calls. "x op= y" and a prefix
+		/// increment prefer an applicable instance operator on the static type of x wherever x is
+		/// a variable - whether or not the result is used; the only forms that always bind the
+		/// static operator are the plain spelling "x = x + y" and a postfix increment whose
+		/// result is used. So the binary operators are written as the former, and an increment as
+		/// "_ = x++", whose discard is what makes the result count as used.
+		/// </summary>
+		TranslatedExpression TranslateShadowedCompoundAssign(UserDefinedCompoundAssign inst, ExpressionWithResolveResult target)
+		{
+			if (inst.Method.Parameters.Count == 2)
+			{
+				var value = Translate(inst.Value).ConvertTo(inst.Method.Parameters[1].Type, this);
+				Expression valueExpr = value.Expression is DirectionExpression dir
+					? dir.Expression.Detach()  // "in" arguments are passed without a modifier
+					: value.Expression;
+				BinaryOperatorType? bop = ReplaceMethodCallsWithOperators.GetBinaryOperatorTypeFromMetadataName(
+					inst.Method.Name, out _, settings);
+				Debug.Assert(bop != null);
+				var binary = new BinaryOperatorExpression((Expression)target.Expression.Clone(), bop.Value, valueExpr)
+					.WithILInstruction(inst)
+					.WithRR(new OperatorResolveResult(inst.Method.ReturnType,
+						BinaryOperatorExpression.GetLinqNodeType(bop.Value, false), inst.Method, inst.IsLifted,
+						new[] { target.ResolveResult, value.ResolveResult }));
+				return new AssignmentExpression(target, AssignmentOperatorType.Assign, binary)
+					.WithILInstruction(inst)
+					.WithRR(new OperatorResolveResult(inst.Method.ReturnType, ExpressionType.Assign,
+						new[] { target.ResolveResult, binary.ResolveResult }));
+			}
+			else
+			{
+				if (HidesVariableWithName("_"))
+				{
+					// A local named "_" would capture the discard, and no other spelling binds the
+					// static operator, so the call is written out even though C# rejects an
+					// explicit operator call: visibly broken output beats silently running the
+					// instance operator.
+					var explicitCall = new InvocationExpression(
+						new MemberReferenceExpression(
+							new TypeReferenceExpression(ConvertType(inst.Method.DeclaringType)),
+							inst.Method.Name),
+						(Expression)target.Expression.Clone())
+						.WithILInstruction(inst)
+						.WithRR(new ResolveResult(inst.Method.ReturnType));
+					return new AssignmentExpression(target, AssignmentOperatorType.Assign, explicitCall)
+						.WithILInstruction(inst)
+						.WithRR(new OperatorResolveResult(inst.Method.ReturnType, ExpressionType.Assign,
+							new[] { target.ResolveResult, explicitCall.ResolveResult }));
+				}
+				UnaryOperatorType? op = GetUnaryOperatorTypeFromMetadataName(inst.Method.Name, isPostfix: true);
+				Debug.Assert(op != null);
+				var unary = new UnaryOperatorExpression(op.Value, target)
+					.WithILInstruction(inst)
+					.WithRR(new OperatorResolveResult(inst.Method.ReturnType,
+						UnaryOperatorExpression.GetLinqNodeType(op.Value, false), inst.Method, inst.IsLifted,
+						new[] { target.ResolveResult }));
+				return new AssignmentExpression(new IdentifierExpression("_"), AssignmentOperatorType.Assign, unary)
+					.WithILInstruction(inst)
+					.WithRR(new OperatorResolveResult(inst.Method.ReturnType, ExpressionType.Assign,
+						new[] { target.ResolveResult, unary.ResolveResult }));
+			}
+		}
+
 		internal static AssignmentOperatorType? GetAssignmentOperatorTypeFromMetadataName(string name, DecompilerSettings settings)
 		{
 			switch (name)
diff --git a/ICSharpCode.Decompiler/CSharp/Resolver/CSharpResolver.cs b/ICSharpCode.Decompiler/CSharp/Resolver/CSharpResolver.cs
index 2cd0f341d5..f894c0f819 100644
--- a/ICSharpCode.Decompiler/CSharp/Resolver/CSharpResolver.cs
+++ b/ICSharpCode.Decompiler/CSharp/Resolver/CSharpResolver.cs
@@ -1245,6 +1245,182 @@ 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.
+		///
+		/// <paramref name="alternateName"/> collects a second operator name in the same pass, for
+		/// callers that have to consider the checked and the unchecked operator together.
+		/// </remarks>
+		public List<IMethod> GetInstanceOperatorCandidates(IType targetType, string name, string alternateName = null)
+		{
+			var candidates = targetType.GetMethods(
+				m => m.IsOperator && !m.IsStatic && m.Accessibility == Accessibility.Public
+					&& (m.Name == name || m.Name == alternateName)
+			).ToList();
+			if (candidates.Count <= 1)
+				return candidates;
+			// 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 bool IsShadowedByInstanceOperator(IMethod method, IType targetType, IType valueType,
+			bool targetIsVariable)
+		{
+			ICompilation compilation = this.Compilation;
+			if (!targetIsVariable)
+				return false;
+			string name = GetCompoundAssignmentOperatorName(method.Name);
+			if (name == null)
+				return false;
+			// Several ILAst nodes are typed by their stack type rather than by the C# type they are
+			// written as, and System.Object then says nothing about what the operator form would
+			// bind against. A user-defined operator always takes its own declaring type, so its
+			// operand is the closest stand-in for the type the C# layer will resolve.
+			if (targetType.IsKnownType(KnownTypeCode.Object) && method.Parameters.Count > 0)
+				targetType = method.Parameters[0].Type.UnwrapByRef();
+			// 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 = IL.UserDefinedCompoundAssign.GetCheckedSiblingName(name);
+			var candidates = GetInstanceOperatorCandidates(targetType, name, checkedName);
+			if (candidates.Count == 0)
+				return false;
+			ResolveResult[] arguments = valueType == null
+				? []
+				: [new ResolveResult(valueType.UnwrapByRef())];
+			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, 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 List<IMethod> GetInstanceOperatorCandidates(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"/> 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 bool WouldRebindOperator(IMethod called, IType receiverType, ResolveResult[] arguments)
+		{
+			ICompilation compilation = this.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(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 3385a2c2a9..1dc2fe1881 100644
--- a/ICSharpCode.Decompiler/CSharp/StatementBuilder.cs
+++ b/ICSharpCode.Decompiler/CSharp/StatementBuilder.cs
@@ -828,18 +828,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);
@@ -1036,6 +1049,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>
@@ -1092,6 +1116,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;
 				}
 			}
@@ -1135,6 +1166,14 @@ bool CanBeDeconstructedInForeach(DeconstructInstruction deconstruction, ILInstru
 					return false;
 				if (!(v.CaptureScope == null || v.CaptureScope == usingContainer))
 					return false;
+				if (settings.UserDefinedCompoundAssignmentOperators
+					&& UserDefinedCompoundAssign.IsCompoundAssignmentReceiver(v))
+				{
+					// The variables a foreach deconstruction designation introduces are read-only,
+					// but an instance compound assignment operator requires an assignable target:
+					// leave the deconstruction in the loop body, where the variables stay writable.
+					return false;
+				}
 				if (!usedVariables.Add(v))
 					return false;
 			}
diff --git a/ICSharpCode.Decompiler/CSharp/Transforms/ReplaceMethodCallsWithOperators.cs b/ICSharpCode.Decompiler/CSharp/Transforms/ReplaceMethodCallsWithOperators.cs
index 6136ec4963..8821af8b17 100644
--- a/ICSharpCode.Decompiler/CSharp/Transforms/ReplaceMethodCallsWithOperators.cs
+++ b/ICSharpCode.Decompiler/CSharp/Transforms/ReplaceMethodCallsWithOperators.cs
@@ -430,7 +430,7 @@ static bool ToStringIsKnownEffectFree(IType type)
 			}
 		}
 
-		static BinaryOperatorType? GetBinaryOperatorTypeFromMetadataName(string name, out bool isChecked, DecompilerSettings settings)
+		internal static BinaryOperatorType? GetBinaryOperatorTypeFromMetadataName(string name, out bool isChecked, DecompilerSettings settings)
 		{
 			isChecked = false;
 			switch (name)
diff --git a/ICSharpCode.Decompiler/IL/Transforms/FixRemainingIncrements.cs b/ICSharpCode.Decompiler/IL/Transforms/FixRemainingIncrements.cs
index 5073752a5d..afce8411e0 100644
--- a/ICSharpCode.Decompiler/IL/Transforms/FixRemainingIncrements.cs
+++ b/ICSharpCode.Decompiler/IL/Transforms/FixRemainingIncrements.cs
@@ -83,7 +83,24 @@ void IILTransform.Run(ILFunction function, ILTransformContext context)
 					Debug.Assert(call.Arguments[0].MatchLdLoc(newVariable));
 					var compoundAssign = new UserDefinedCompoundAssign(call.Method, CompoundEvalMode.EvaluatesToNewValue,
 						new LdLoca(newVariable), CompoundTargetKind.Address, new LdcI4(1)).WithILRange(call);
-					call.ReplaceWith(compoundAssign);
+					if (context.Settings.UserDefinedCompoundAssignmentOperators
+						&& context.CSharpResolver.IsShadowedByInstanceOperator(call.Method, newVariable.Type, null,
+							targetIsVariable: true)
+						&& newVariable.StoreInstructions.SingleOrDefault() is StLoc { Parent: Block hoistBlock } hoistedStore)
+					{
+						// A prefix increment here would bind the C# 14 instance operator of the
+						// same name; only a postfix increment with a used result binds the static
+						// one, and that hands back the old value. So the increment becomes a
+						// statement of its own, right after the extracted argument. This can move
+						// the operator call ahead of side effects that originally ran before it;
+						// the alternative is output that silently calls the other operator.
+						hoistBlock.Instructions.Insert(hoistedStore.ChildIndex + 1, compoundAssign);
+						call.ReplaceWith(new LdLoc(newVariable));
+					}
+					else
+					{
+						call.ReplaceWith(compoundAssign);
+					}
 					context.EndStep(compoundAssign);
 				}
 			}
diff --git a/ICSharpCode.Decompiler/IL/Transforms/TransformAssignment.cs b/ICSharpCode.Decompiler/IL/Transforms/TransformAssignment.cs
index 8edba814aa..a27b33a757 100644
--- a/ICSharpCode.Decompiler/IL/Transforms/TransformAssignment.cs
+++ b/ICSharpCode.Decompiler/IL/Transforms/TransformAssignment.cs
@@ -403,6 +403,19 @@ internal static bool HandleCompoundAssign(ILInstruction compoundStore, Statement
 				{
 					if (!UserDefinedCompoundAssign.IsIncrementOrDecrement(operatorCall.Method, context.Settings))
 						return false;
+					// An increment whose result is used has to be written as a prefix increment,
+					// which prefers an applicable C# 14 instance operator over the static one this
+					// call names. There is no expression form that binds the static operator (only
+					// a used postfix result does, and that hands back the old value), so the call
+					// stays a call here; FixRemainingIncrements turns it into a statement of its
+					// own, where a postfix increment with a discarded result can bind it.
+					if (compoundStore.SlotInfo != Block.InstructionSlot
+						&& context.Settings.UserDefinedCompoundAssignmentOperators
+						&& context.CSharpResolver.IsShadowedByInstanceOperator(operatorCall.Method, targetType, null,
+							targetIsVariable: compoundStore is not CallInstruction))
+					{
+						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);
 				}
@@ -892,6 +905,14 @@ bool TransformPreIncDecOperatorWithInlineStore(Block block, int pos)
 			{
 				if (!(operatorCall.Method.Name == "op_Increment" || operatorCall.Method.Name == "op_Decrement"))
 					return false;
+				// The result of this fold is used, so it would be written as a prefix increment,
+				// which prefers an applicable C# 14 instance operator; see HandleCompoundAssign.
+				if (context.Settings.UserDefinedCompoundAssignmentOperators
+					&& context.CSharpResolver.IsShadowedByInstanceOperator(operatorCall.Method, targetType, null,
+						targetIsVariable: true))
+				{
+					return false;
+				}
 				if (operatorCall.IsLifted)
 					return false; // TODO: add tests and think about whether nullables need special considerations
 				ldloc = operatorCall.Arguments[0] as LdLoc;

From 91dd944d29a3b071b12610eeac1729faea8557fa Mon Sep 17 00:00:00 2001
From: Siegfried Pammer <siegfriedpammer@gmail.com>
Date: Sat, 29 Aug 2026 06:46:37 +0200
Subject: [PATCH 4/7] Fold instance operator calls into compound assignment
 syntax

A call to an instance compound assignment operator becomes "x op= y" or "x++"
only when C# would accept the receiver in that position and bind the same
operator there: the receiver has to be an assignable variable (rather than
"this" in a class, a foreach or using variable, an "in" parameter, or a
readonly field outside its constructor), an operator declared in an interface
needs an interface- or type-parameter-typed receiver, and the operator form
cannot pick an overload by parameter modifier, so a call to an "in" overload
whose by-value sibling is applicable stays a call. A non-public operator has no
operator form at all (CS9308), and stays a call too.

In the other direction, "x = x + y" keeps the explicit spelling wherever
folding it to "x += y" would hand the statement to an applicable instance
operator.

Assisted-by: Claude:claude-opus-5:Claude Code
---
 .../Transforms/PatternStatementTransform.cs   |  10 +
 .../CSharp/Transforms/PrettifyAssignments.cs  |  20 +-
 .../ReplaceMethodCallsWithOperators.cs        | 219 ++++++++++++++++++
 3 files changed, 248 insertions(+), 1 deletion(-)

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..a531b01481 100644
--- a/ICSharpCode.Decompiler/CSharp/Transforms/PrettifyAssignments.cs
+++ b/ICSharpCode.Decompiler/CSharp/Transforms/PrettifyAssignments.cs
@@ -24,6 +24,7 @@
 
 using ICSharpCode.Decompiler.CSharp.Resolver;
 using ICSharpCode.Decompiler.CSharp.Syntax;
+using ICSharpCode.Decompiler.Semantics;
 using ICSharpCode.Decompiler.CSharp.Syntax.PatternMatching;
 using ICSharpCode.Decompiler.TypeSystem;
 using ICSharpCode.Decompiler.Util;
@@ -61,7 +62,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 +104,22 @@ 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.
+				// GetSymbol has no OperatorResolveResult mapping, so the method behind an operator
+				// expression has to be read off the resolve result itself.
+				IMethod? method = binary.GetSymbol() as IMethod
+					?? (binary.GetResolveResult() as OperatorResolveResult)?.UserDefinedOperatorMethod;
+				return binary.Right != null && method != null
+					&& context.Settings.UserDefinedCompoundAssignmentOperators
+					&& new CSharpResolver(context.TypeSystem).IsShadowedByInstanceOperator(method,
+						assignment.Left.GetResolveResult().Type, binary.Right.GetResolveResult().Type,
+						targetIsVariable: assignment.Left.GetSymbol() is not IProperty);
+			}
+
 			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 8821af8b17..324d7b1568 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 (new CSharpResolver(context.TypeSystem).WouldRebindOperator(method, receiverType, [value.GetResolveResult()]))
+						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)),

From e4fa167afc9b8a9f9485dea83b23b62cd006d6b0 Mon Sep 17 00:00:00 2001
From: Siegfried Pammer <siegfriedpammer@gmail.com>
Date: Sat, 29 Aug 2026 06:47:15 +0200
Subject: [PATCH 5/7] Render user-defined compound assignment operator
 declarations

TypeSystemAstBuilder writes the C# 14 "operator +=" declaration form, behind a
support flag like the other version-gated operator syntax; a non-public
operator has no legal operator declaration (CS9308) and falls back to a plain
method, except an explicit interface implementation, which is private in
metadata but still written in operator form. An instance operator hides by
signature like an ordinary method, so it can carry "new"; the
[CompilerFeatureRequired] marker the compiler emits is removed like the other
feature markers. Tooltips get the same rendering via a ConversionFlags bit;
widening ConversionFlags.All also turns on the existing checked-operator and
unsigned-right-shift flags, which the tooltip ambience now sets explicitly.

The test fixtures land here, where the pipeline is complete end to end: pretty
and IL round-trips, correctness runs against Roslyn's C# 14 binding (including
the operator-inheritance matrix and a ref-local target), and the ugly
configuration pins the output with the setting off.

Assisted-by: Claude:claude-opus-5:Claude Code
---
 .../CorrectnessTestRunner.cs                  |  18 +
 .../ICSharpCode.Decompiler.Tests.csproj       |   3 +
 .../ILPrettyTestRunner.cs                     |   6 +
 .../Output/CSharpAmbienceTests.cs             |  53 +-
 .../PrettyTestRunner.cs                       |   6 +
 .../UserDefinedCompoundAssignment.cs          | 329 +++++++++
 ...serDefinedCompoundAssignmentInheritance.cs | 681 ++++++++++++++++++
 .../CompoundAssignmentOperatorEdgeCases.cs    | 243 +++++++
 .../CompoundAssignmentOperatorEdgeCases.il    | 522 ++++++++++++++
 .../Pretty/UserDefinedCompoundAssignment.cs   | 628 ++++++++++++++++
 .../CSharp/CSharpDecompiler.cs                |  17 +-
 .../CSharp/OutputVisitor/CSharpAmbience.cs    |   4 +-
 .../CSharp/Syntax/TypeSystemAstBuilder.cs     |  15 +-
 ICSharpCode.Decompiler/Output/IAmbience.cs    |   6 +-
 ICSharpCode.ILSpyCmd/IlspyCmdProgram.cs       |   2 +-
 ILSpy/Languages/CSharpLanguage.cs             |   4 +-
 16 files changed, 2527 insertions(+), 10 deletions(-)
 create mode 100644 ICSharpCode.Decompiler.Tests/TestCases/Correctness/UserDefinedCompoundAssignment.cs
 create mode 100644 ICSharpCode.Decompiler.Tests/TestCases/Correctness/UserDefinedCompoundAssignmentInheritance.cs
 create mode 100644 ICSharpCode.Decompiler.Tests/TestCases/ILPretty/CompoundAssignmentOperatorEdgeCases.cs
 create mode 100644 ICSharpCode.Decompiler.Tests/TestCases/ILPretty/CompoundAssignmentOperatorEdgeCases.il
 create mode 100644 ICSharpCode.Decompiler.Tests/TestCases/Pretty/UserDefinedCompoundAssignment.cs

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 af25b88276..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" />
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 01b6228c96..45afed5cba 100644
--- a/ICSharpCode.Decompiler.Tests/PrettyTestRunner.cs
+++ b/ICSharpCode.Decompiler.Tests/PrettyTestRunner.cs
@@ -836,6 +836,12 @@ public async Task FirstClassSpanConversions([ValueSource(nameof(roslyn5OrNewerOp
 			await RunForLibrary(cscOptions: cscOptions);
 		}
 
+		[Test]
+		public async Task UserDefinedCompoundAssignment([ValueSource(nameof(roslyn5OrNewerOptions))] CompilerOptions cscOptions)
+		{
+			await RunForLibrary(cscOptions: cscOptions);
+		}
+
 		[Test]
 		public async Task ExpandParamsArgumentsDisabled([ValueSource(nameof(defaultOptions))] CompilerOptions cscOptions)
 		{
diff --git a/ICSharpCode.Decompiler.Tests/TestCases/Correctness/UserDefinedCompoundAssignment.cs b/ICSharpCode.Decompiler.Tests/TestCases/Correctness/UserDefinedCompoundAssignment.cs
new file mode 100644
index 0000000000..f906572e23
--- /dev/null
+++ b/ICSharpCode.Decompiler.Tests/TestCases/Correctness/UserDefinedCompoundAssignment.cs
@@ -0,0 +1,329 @@
+// 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();
+			StaticOperatorOnRefLocalStaysStatic();
+			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 StaticOperatorOnRefLocalStaysStatic()
+		{
+			Both[] arr = new Both[1] { new Both { Value = 1 } };
+			ref Both r = ref arr[0];
+			r = r + 5;
+			Console.WriteLine("StaticOperatorOnRefLocalStaysStatic: " + arr[0].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..7540202bce
--- /dev/null
+++ b/ICSharpCode.Decompiler.Tests/TestCases/ILPretty/CompoundAssignmentOperatorEdgeCases.cs
@@ -0,0 +1,243 @@
+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 ShadowTarget Shared;
+
+	// A statement-level "x++" considers the instance operator first; the only form that always
+	// binds the static operator is a postfix increment whose result is used, so the result goes
+	// to a discard.
+	public static void StatementLevelPostIncrement()
+	{
+		_ = Shared++;
+	}
+
+	// A pre-increment whose result is used prefers the instance operator too, so the increment
+	// becomes a statement of its own before the uses of the new value.
+	public static void ValueUsedPreIncrement()
+	{
+		ShadowTarget shared = Shared;
+		_ = shared++;
+		UseValue(Shared = shared);
+	}
+
+	public static void UseValue(ShadowTarget t)
+	{
+	}
+
+	// The same holds for the shape that stores the old value inside the operator call.
+	public static void InlineStorePostIncrement()
+	{
+		_ = Shared++;
+	}
+
+	// An array element is a variable, so a statement-level "++arr[0]" would bind the instance
+	// operator too.
+	public static void ArrayElementIncrement(ShadowTarget[] arr)
+	{
+		ShadowTarget shadowTarget = arr[0];
+		_ = shadowTarget++;
+		arr[0] = shadowTarget;
+	}
+
+	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);
+	}
+
+	// A prefix increment prefers the instance "operator ++()" even where its result is used, so
+	// the increment is a statement with a discarded postfix result; the copy keeps the
+	// parameter unchanged, as in the IL.
+	public static ShadowTarget ShadowedIncrement(ShadowTarget x)
+	{
+		ShadowTarget result = x;
+		_ = result++;
+		return result;
+	}
+
+	public static void CallNonCSharpOperators(CompoundTarget t, int n)
+	{
+		t.op_SubtractionAssignment(n);
+		CompoundTarget.op_MultiplicationAssignment(t, n);
+	}
+
+	// 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; a postfix increment with
+	// its result discarded binds the static one.
+	public static CovariantDerived CovariantIncrement(CovariantDerived d)
+	{
+		CovariantDerived covariantDerived = d;
+		_ = covariantDerived++;
+		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..6e2ec1b15c
--- /dev/null
+++ b/ICSharpCode.Decompiler.Tests/TestCases/ILPretty/CompoundAssignmentOperatorEdgeCases.il
@@ -0,0 +1,522 @@
+// 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
+  .field public static class ShadowTarget Shared
+
+  // The post-increment shape legacy csc emits: the old value goes to a temp that nothing reads,
+  // so the increment is written as a statement, where C# considers the instance operator first.
+  .method public hidebysig static void  StatementLevelPostIncrement() cil managed
+  {
+    .maxstack  2
+    .locals init (class ShadowTarget V_0)
+    IL_0000:  ldsfld     class ShadowTarget EdgeCases::Shared
+    IL_0005:  stloc.0
+    IL_0006:  ldloc.0
+    IL_0007:  call       class ShadowTarget ShadowTarget::op_Increment(class ShadowTarget)
+    IL_000c:  stsfld     class ShadowTarget EdgeCases::Shared
+    IL_0011:  ret
+  }
+
+  // A pre-increment whose result is used: a prefix increment would bind the instance operator,
+  // so the increment has to become a statement of its own before the uses of the new value.
+  .method public hidebysig static void  ValueUsedPreIncrement() cil managed
+  {
+    .maxstack  2
+    IL_0000:  ldsfld     class ShadowTarget EdgeCases::Shared
+    IL_0005:  call       class ShadowTarget ShadowTarget::op_Increment(class ShadowTarget)
+    IL_000a:  dup
+    IL_000b:  stsfld     class ShadowTarget EdgeCases::Shared
+    IL_0010:  call       void EdgeCases::UseValue(class ShadowTarget)
+    IL_0015:  ret
+  }
+
+  .method public hidebysig static void  UseValue(class ShadowTarget t) cil managed
+  {
+    .maxstack  8
+    IL_0000:  ret
+  }
+
+  // The other legacy post-increment shape, storing the old value inside the operator call: it is
+  // written as a statement too where nothing reads that value.
+  .method public hidebysig static void  InlineStorePostIncrement() cil managed
+  {
+    .maxstack  3
+    .locals init (class ShadowTarget V_0)
+    IL_0000:  ldsfld     class ShadowTarget EdgeCases::Shared
+    IL_0005:  dup
+    IL_0006:  stloc.0
+    IL_0007:  call       class ShadowTarget ShadowTarget::op_Increment(class ShadowTarget)
+    IL_000c:  stsfld     class ShadowTarget EdgeCases::Shared
+    IL_0011:  ret
+  }
+
+  // An array element is a variable, and "ldelem.ref" leaves the reader with the stack type
+  // rather than with the element type.
+  .method public hidebysig static void  ArrayElementIncrement(class ShadowTarget[] arr) cil managed
+  {
+    .maxstack  3
+    .locals init (class ShadowTarget V_0)
+    IL_0000:  ldarg.0
+    IL_0001:  dup
+    IL_0002:  ldc.i4.0
+    IL_0003:  ldelem.ref
+    IL_0004:  call       class ShadowTarget ShadowTarget::op_Increment(class ShadowTarget)
+    IL_0009:  stloc.0
+    IL_000a:  ldc.i4.0
+    IL_000b:  ldloc.0
+    IL_000c:  stelem.ref
+    IL_000d:  ret
+  }
+
+  .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..52d9f17134
--- /dev/null
+++ b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/UserDefinedCompoundAssignment.cs
@@ -0,0 +1,628 @@
+// 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 class InParameterOperators
+		{
+			public int Value;
+
+			public static InParameterOperators operator +(InParameterOperators lhs, in InParameterOperators rhs)
+			{
+				return new InParameterOperators {
+					Value = lhs.Value + rhs.Value
+				};
+			}
+
+			public void operator +=(in InParameterOperators rhs)
+			{
+				Value += rhs.Value;
+			}
+		}
+
+		public class ShadowingInParameterOperators : InParameterOperators
+		{
+			public new void operator +=(in InParameterOperators rhs)
+			{
+				Value += rhs.Value * 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 UseStaticOperatorOnRefLocal(BothOperators[] arr, int n)
+		{
+			// A ref local is a variable, so "r += n" would bind the instance operator here too.
+			ref BothOperators reference = ref arr[0];
+			reference = reference + n;
+			reference = reference + 1;
+		}
+
+		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 UseCheckedOperatorOfBaseTypedLocal(ShadowingCompoundClass s, int n)
+		{
+			// The derived type hides only the regular flavor, but a checked context does not
+			// exclude regular operators - it prefers a checked one within the type that wins the
+			// lookup. On a derived-typed receiver the hiding operator would take this call, so
+			// the base-typed local has to survive here too.
+			CompoundClass compoundClass = s;
+			checked
+			{
+				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++;
+		}
+
+		public static void KeepStaticOperatorWithInParameter(InParameterOperators x, InParameterOperators y)
+		{
+			// "x += y" binds the instance operator, so folding the static call the IL makes into
+			// the operator form would change which operator runs.
+			x = x + y;
+		}
+
+		public static void UseCopyForShadowedInParameterOperator(ShadowingInParameterOperators s, InParameterOperators y)
+		{
+			// The receiver has to keep the base type: the derived type hides the operator with a
+			// "new" one, which the operator form would bind instead.
+			InParameterOperators inParameterOperators = s;
+			inParameterOperators += y;
+		}
+
+		public static void UseForeachDeconstructionCopy(List<(CompoundClass, int)> list, int n)
+		{
+			// The variables a foreach deconstruction designation introduces are read-only, so the
+			// deconstruction stays in the body, where the operator has an assignable target.
+			foreach (var item in list)
+			{
+				var (compoundClass, value) = item;
+				compoundClass += n;
+				Console.WriteLine(value);
+			}
+		}
+	}
+}
diff --git a/ICSharpCode.Decompiler/CSharp/CSharpDecompiler.cs b/ICSharpCode.Decompiler/CSharp/CSharpDecompiler.cs
index ed06687341..0c872d55e5 100644
--- a/ICSharpCode.Decompiler/CSharp/CSharpDecompiler.cs
+++ b/ICSharpCode.Decompiler/CSharp/CSharpDecompiler.cs
@@ -827,6 +827,7 @@ static TypeSystemAstBuilder CreateAstBuilder(DecompilerSettings settings)
 			typeSystemAstBuilder.SupportOperatorChecked = settings.CheckedOperators;
 			typeSystemAstBuilder.AlwaysUseGlobal = settings.AlwaysUseGlobal;
 			typeSystemAstBuilder.SupportExtensionDeclarations = settings.ExtensionMembers;
+			typeSystemAstBuilder.SupportUserDefinedCompoundAssignmentOperators = settings.UserDefinedCompoundAssignmentOperators;
 			return typeSystemAstBuilder;
 		}
 
@@ -1730,15 +1731,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))))
 							{
@@ -2245,8 +2247,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))
 				{
@@ -2272,6 +2277,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/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/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/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.ILSpyCmd/IlspyCmdProgram.cs b/ICSharpCode.ILSpyCmd/IlspyCmdProgram.cs
index 15e74dab4c..bbe3dc2e04 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 10a46c120e..ff5a373e21 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)

From 67e22d7057a4e62ae5236fd7cfff42e255b4a95e Mon Sep 17 00:00:00 2001
From: Siegfried Pammer <siegfriedpammer@gmail.com>
Date: Sat, 29 Aug 2026 10:18:05 +0200
Subject: [PATCH 6/7] Flush pending side effects before materializing an
 operator receiver

The receiver slot is appended to the current block, but the expression stack
was only flushed inside the per-parameter loop - which the increment operators,
taking no parameters, never enter. A side effect still pending on the stack was
then emitted after the receiver read it should precede, so the increment
applied to a stale value of the field it targets.

Assisted-by: Claude:claude-opus-5:Claude Code
---
 .../CompoundAssignmentOperatorEdgeCases.cs    | 21 ++++++++++++
 .../CompoundAssignmentOperatorEdgeCases.il    | 34 +++++++++++++++++++
 ICSharpCode.Decompiler/IL/ILReader.cs         |  7 ++++
 3 files changed, 62 insertions(+)

diff --git a/ICSharpCode.Decompiler.Tests/TestCases/ILPretty/CompoundAssignmentOperatorEdgeCases.cs b/ICSharpCode.Decompiler.Tests/TestCases/ILPretty/CompoundAssignmentOperatorEdgeCases.cs
index 7540202bce..47f8f8d8b1 100644
--- a/ICSharpCode.Decompiler.Tests/TestCases/ILPretty/CompoundAssignmentOperatorEdgeCases.cs
+++ b/ICSharpCode.Decompiler.Tests/TestCases/ILPretty/CompoundAssignmentOperatorEdgeCases.cs
@@ -89,6 +89,8 @@ public class EdgeCases
 
 	public static ShadowTarget Shared;
 
+	public ShadowTarget mutableField;
+
 	// A statement-level "x++" considers the instance operator first; the only form that always
 	// binds the static operator is a postfix increment whose result is used, so the result goes
 	// to a discard.
@@ -97,6 +99,25 @@ public static void StatementLevelPostIncrement()
 		_ = Shared++;
 	}
 
+	public ShadowTarget ReassignField()
+	{
+		mutableField = new ShadowTarget();
+		return null;
+	}
+
+	public static void UseTwo(object o, ShadowTarget t)
+	{
+	}
+
+	// The receiver read must not be hoisted above side effects already pending on the
+	// expression stack: ReassignField() replaces the field the increment then applies to.
+	public void IncrementAfterPendingSideEffect()
+	{
+		ShadowTarget o = ReassignField();
+		mutableField++;
+		UseTwo(o, mutableField);
+	}
+
 	// A pre-increment whose result is used prefers the instance operator too, so the increment
 	// becomes a statement of its own before the uses of the new value.
 	public static void ValueUsedPreIncrement()
diff --git a/ICSharpCode.Decompiler.Tests/TestCases/ILPretty/CompoundAssignmentOperatorEdgeCases.il b/ICSharpCode.Decompiler.Tests/TestCases/ILPretty/CompoundAssignmentOperatorEdgeCases.il
index 6e2ec1b15c..3a23174618 100644
--- a/ICSharpCode.Decompiler.Tests/TestCases/ILPretty/CompoundAssignmentOperatorEdgeCases.il
+++ b/ICSharpCode.Decompiler.Tests/TestCases/ILPretty/CompoundAssignmentOperatorEdgeCases.il
@@ -188,6 +188,40 @@
     IL_0011:  ret
   }
 
+  .field public class ShadowTarget mutableField
+
+  .method public hidebysig instance class ShadowTarget ReassignField() cil managed
+  {
+    .maxstack  8
+    IL_0000:  ldarg.0
+    IL_0001:  newobj     instance void ShadowTarget::.ctor()
+    IL_0006:  stfld      class ShadowTarget EdgeCases::mutableField
+    IL_000b:  ldnull
+    IL_000c:  ret
+  }
+
+  .method public hidebysig static void  UseTwo(object o, class ShadowTarget t) cil managed
+  {
+    .maxstack  8
+    IL_0000:  ret
+  }
+
+  // The receiver read must not be hoisted above side effects already pending on the
+  // expression stack: ReassignField() replaces the field the increment then applies to.
+  .method public hidebysig instance void  IncrementAfterPendingSideEffect() cil managed
+  {
+    .maxstack  3
+    IL_0000:  ldarg.0
+    IL_0001:  call       instance class ShadowTarget EdgeCases::ReassignField()
+    IL_0006:  ldarg.0
+    IL_0007:  ldfld      class ShadowTarget EdgeCases::mutableField
+    IL_000c:  callvirt   instance void ShadowTarget::op_IncrementAssignment()
+    IL_0011:  ldarg.0
+    IL_0012:  ldfld      class ShadowTarget EdgeCases::mutableField
+    IL_0017:  call       void EdgeCases::UseTwo(object, class ShadowTarget)
+    IL_001c:  ret
+  }
+
   // A pre-increment whose result is used: a prefix increment would bind the instance operator,
   // so the increment has to become a statement of its own before the uses of the new value.
   .method public hidebysig static void  ValueUsedPreIncrement() cil managed
diff --git a/ICSharpCode.Decompiler/IL/ILReader.cs b/ICSharpCode.Decompiler/IL/ILReader.cs
index bd73725c1b..8d3065a1be 100644
--- a/ICSharpCode.Decompiler/IL/ILReader.cs
+++ b/ICSharpCode.Decompiler/IL/ILReader.cs
@@ -1840,6 +1840,13 @@ ILInstruction[] PrepareArguments(bool firstArgumentIsStObjTarget)
 				// 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;
+				if (materializeReceiver)
+				{
+					// The receiver slot is appended to the current block, so everything still
+					// pending on the expression stack has to be flushed first - the parameter
+					// loop below does that too, but the increment operators take no parameters.
+					FlushExpressionStack();
+				}
 				for (int i = method.Parameters.Count - 1; i >= 0; i--)
 				{
 					if (requiresLdObjIfRef || materializeReceiver)

From 826cf02254f4dcebd3e0097a2930d10998dd29af Mon Sep 17 00:00:00 2001
From: Siegfried Pammer <siegfriedpammer@gmail.com>
Date: Sat, 29 Aug 2026 10:22:56 +0200
Subject: [PATCH 7/7] Confine the receiver machinery to instance compound
 assignment operators

The reader's receiver materialization, the inlining slot restriction, and the
receiver-use predicate keyed on any instance operator, so C++/CLI-style
value-returning classic operators - which have an ordinary call spelling and
need none of it - got their receivers spilled into locals. CallBuilder had the
mirror problem: it took classic instance operators off the candidate path they
always used. One predicate now decides what the machinery applies to: an
instance operator under one of the op_*Assignment names, which classification
already guarantees has the C# 14 shape.

Assisted-by: Claude:claude-opus-5:Claude Code
---
 .../CompoundAssignmentOperatorEdgeCases.cs    | 22 ++++++++++
 .../CompoundAssignmentOperatorEdgeCases.il    | 41 +++++++++++++++++++
 ICSharpCode.Decompiler/CSharp/CallBuilder.cs  |  4 +-
 ICSharpCode.Decompiler/IL/ILReader.cs         |  2 +-
 .../IL/Instructions/CallInstruction.cs        |  2 +-
 .../CompoundAssignmentInstruction.cs          | 16 +++++++-
 6 files changed, 82 insertions(+), 5 deletions(-)

diff --git a/ICSharpCode.Decompiler.Tests/TestCases/ILPretty/CompoundAssignmentOperatorEdgeCases.cs b/ICSharpCode.Decompiler.Tests/TestCases/ILPretty/CompoundAssignmentOperatorEdgeCases.cs
index 47f8f8d8b1..a8f2202cf1 100644
--- a/ICSharpCode.Decompiler.Tests/TestCases/ILPretty/CompoundAssignmentOperatorEdgeCases.cs
+++ b/ICSharpCode.Decompiler.Tests/TestCases/ILPretty/CompoundAssignmentOperatorEdgeCases.cs
@@ -35,6 +35,16 @@ public void op_MultiplicationAssignment(params int[] rhs)
 	{
 	}
 }
+// A C++/CLI-style classic operator: a value-returning instance op_Addition. It has an ordinary
+// call spelling, so none of the compound assignment receiver machinery applies to it; the
+// instance operator declaration form is longstanding behavior for such methods.
+public class ClassicInstanceOperator
+{
+	public ClassicInstanceOperator operator +(ClassicInstanceOperator other)
+	{
+		return this;
+	}
+}
 public class CompoundTarget
 {
 	public int Value;
@@ -131,6 +141,18 @@ public static void UseValue(ShadowTarget t)
 	{
 	}
 
+	public static ClassicInstanceOperator GetClassic()
+	{
+		return new ClassicInstanceOperator();
+	}
+
+	// The receiver is an r-value; a compound assignment receiver would have to be spilled to a
+	// variable, but a classic operator call needs no such thing.
+	public static void CallClassicOperatorOnRValue(ClassicInstanceOperator x)
+	{
+		GetClassic().op_Addition(x);
+	}
+
 	// The same holds for the shape that stores the old value inside the operator call.
 	public static void InlineStorePostIncrement()
 	{
diff --git a/ICSharpCode.Decompiler.Tests/TestCases/ILPretty/CompoundAssignmentOperatorEdgeCases.il b/ICSharpCode.Decompiler.Tests/TestCases/ILPretty/CompoundAssignmentOperatorEdgeCases.il
index 3a23174618..ce3ef78819 100644
--- a/ICSharpCode.Decompiler.Tests/TestCases/ILPretty/CompoundAssignmentOperatorEdgeCases.il
+++ b/ICSharpCode.Decompiler.Tests/TestCases/ILPretty/CompoundAssignmentOperatorEdgeCases.il
@@ -168,6 +168,28 @@
   }
 }
 
+// A C++/CLI-style classic operator: a value-returning instance op_Addition. It has an
+// ordinary call spelling, so none of the compound assignment receiver machinery applies.
+.class public auto ansi beforefieldinit ClassicInstanceOperator
+       extends [System.Runtime]System.Object
+{
+  .method public hidebysig specialname instance class ClassicInstanceOperator
+          op_Addition(class ClassicInstanceOperator other) 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 EdgeCases
        extends [System.Runtime]System.Object
 {
@@ -241,6 +263,25 @@
     IL_0000:  ret
   }
 
+  .method public hidebysig static class ClassicInstanceOperator GetClassic() cil managed
+  {
+    .maxstack  8
+    IL_0000:  newobj     instance void ClassicInstanceOperator::.ctor()
+    IL_0005:  ret
+  }
+
+  // The receiver is an r-value; a compound assignment receiver would have to be spilled to a
+  // variable, but a classic operator call needs no such thing.
+  .method public hidebysig static void  CallClassicOperatorOnRValue(class ClassicInstanceOperator x) cil managed
+  {
+    .maxstack  8
+    IL_0000:  call       class ClassicInstanceOperator EdgeCases::GetClassic()
+    IL_0005:  ldarg.0
+    IL_0006:  callvirt   instance class ClassicInstanceOperator ClassicInstanceOperator::op_Addition(class ClassicInstanceOperator)
+    IL_000b:  pop
+    IL_000c:  ret
+  }
+
   // The other legacy post-increment shape, storing the old value inside the operator call: it is
   // written as a statement too where nothing reads that value.
   .method public hidebysig static void  InlineStorePostIncrement() cil managed
diff --git a/ICSharpCode.Decompiler/CSharp/CallBuilder.cs b/ICSharpCode.Decompiler/CSharp/CallBuilder.cs
index aa88ffe41a..356de2b1b7 100644
--- a/ICSharpCode.Decompiler/CSharp/CallBuilder.cs
+++ b/ICSharpCode.Decompiler/CSharp/CallBuilder.cs
@@ -1667,7 +1667,7 @@ OverloadResolutionErrors IsUnambiguousCall(ExpectedTargetDetails expectedTargetD
 					}
 				}
 			}
-			else if (method.IsOperator && method.IsStatic)
+			else if (method.IsOperator && !IL.UserDefinedCompoundAssign.IsInstanceCompoundAssignmentOperator(method))
 			{
 				IEnumerable<IParameterizedMember> operatorCandidates;
 				if (arguments.Length == 1)
@@ -1703,7 +1703,7 @@ OverloadResolutionErrors IsUnambiguousCall(ExpectedTargetDetails expectedTargetD
 					or.AddCandidate(m);
 				}
 			}
-			else if (settings.UserDefinedCompoundAssignmentOperators && method.IsOperator && !method.IsStatic && target != null)
+			else if (IL.UserDefinedCompoundAssign.IsInstanceCompoundAssignmentOperator(method) && 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
diff --git a/ICSharpCode.Decompiler/IL/ILReader.cs b/ICSharpCode.Decompiler/IL/ILReader.cs
index 8d3065a1be..8c19e97352 100644
--- a/ICSharpCode.Decompiler/IL/ILReader.cs
+++ b/ICSharpCode.Decompiler/IL/ILReader.cs
@@ -1823,7 +1823,7 @@ bool ReceiverLooksLikeValueTypeTarget()
 
 			bool IsNonStaticOperatorCall()
 			{
-				return method.IsOperator && !method.IsStatic;
+				return UserDefinedCompoundAssign.IsInstanceCompoundAssignmentOperator(method);
 			}
 
 			ILInstruction[] PrepareArguments(bool firstArgumentIsStObjTarget)
diff --git a/ICSharpCode.Decompiler/IL/Instructions/CallInstruction.cs b/ICSharpCode.Decompiler/IL/Instructions/CallInstruction.cs
index ff2cfc82b4..28b5027a09 100644
--- a/ICSharpCode.Decompiler/IL/Instructions/CallInstruction.cs
+++ b/ICSharpCode.Decompiler/IL/Instructions/CallInstruction.cs
@@ -177,7 +177,7 @@ internal override bool SatisfiesSlotRestrictionForInlining(int childIndex, ILIns
 			// target of "x op= y", so the expression taking its place has to be one C# accepts
 			// there and one that still binds the operator this call names. Classification already
 			// implies the corresponding decompiler setting is on.
-			if (childIndex == 0 && Method.IsOperator && !Method.IsStatic
+			if (childIndex == 0 && UserDefinedCompoundAssign.IsInstanceCompoundAssignmentOperator(Method)
 				&& !CanBeCompoundAssignmentReceiver(newChild))
 			{
 				return false;
diff --git a/ICSharpCode.Decompiler/IL/Instructions/CompoundAssignmentInstruction.cs b/ICSharpCode.Decompiler/IL/Instructions/CompoundAssignmentInstruction.cs
index de8c72c9c6..378a8940c0 100644
--- a/ICSharpCode.Decompiler/IL/Instructions/CompoundAssignmentInstruction.cs
+++ b/ICSharpCode.Decompiler/IL/Instructions/CompoundAssignmentInstruction.cs
@@ -350,6 +350,19 @@ public static bool IsCompoundAssignmentReceiver(ILVariable variable)
 				.Any(IsCompoundAssignmentReceiverUse);
 		}
 
+		/// <summary>
+		/// Gets whether the method is a C# 14 instance compound assignment operator - the only
+		/// kind of operator whose call sites must be written as "x op= y" / "x++". Other
+		/// languages' instance operators (C++/CLI's value-returning op_Addition, say) have an
+		/// ordinary call spelling and none of the receiver machinery applies to them.
+		/// </summary>
+		public static bool IsInstanceCompoundAssignmentOperator(IMethod method)
+		{
+			return method is { IsOperator: true, IsStatic: false }
+				&& CSharp.Syntax.OperatorDeclaration.GetOperatorType(method.Name) is CSharp.Syntax.OperatorType operatorType
+				&& CSharp.Syntax.OperatorDeclaration.IsCompoundAssignment(operatorType);
+		}
+
 		/// <summary>
 		/// Gets the metadata name of the checked operator paired with an unchecked one, and vice
 		/// versa. Which of the two "x op= y" binds depends on the checked context the assignment
@@ -368,7 +381,8 @@ public static string GetCheckedSiblingName(string operatorName)
 		/// </summary>
 		public static bool IsCompoundAssignmentReceiverUse(ILInstruction inst)
 		{
-			return inst.Parent is CallInstruction { Method: { IsOperator: true, IsStatic: false } } call
+			return inst.Parent is CallInstruction call
+				&& IsInstanceCompoundAssignmentOperator(call.Method)
 				&& call.Arguments.Count > 0 && call.Arguments[0] == inst;
 		}