Add a treenode and decompiler APIs for extensions.

ICSharpCode.Decompiler.Tests/TestCases/Pretty/ExtensionEverything.cs

@@ -1,9 +1,49 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Text.RegularExpressions;
 
 namespace ICSharpCode.Decompiler.Tests.TestCases.Pretty
 {
+	internal static class EmptyGroups
+	{
+		extension(int)
+		{
+		}
+
+		extension(int x)
+		{
+		}
+
+		extension(int y)
+		{
+		}
+
+		extension<T>(IEnumerable<T>)
+		{
+		}
+
+		extension<T>(IEnumerable<T> x)
+		{
+		}
+
+		extension<T>(IEnumerable<T> y)
+		{
+		}
+
+		extension<TKey, TValue>(Dictionary<TKey, TValue>)
+		{
+		}
+
+		extension<TKey, TValue>(Dictionary<TKey, TValue> x)
+		{
+		}
+
+		extension<TKey, TValue>(Dictionary<TKey, TValue> y)
+		{
+		}
+	}
+
 	internal static class ExtensionEverything
 	{
 		extension<T>(ICollection<T> collection) where T : notnull
@@ -40,6 +80,21 @@ namespace ICSharpCode.Decompiler.Tests.TestCases.Pretty
 		{
 			public double Magnitude => Math.Sqrt(point.X * point.X + point.Y * point.Y);
 		}
+
+		extension(ref ExtensionEverythingTestUseSites.Point point)
+		{
+			public double MagnitudeRef => Math.Sqrt(point.X * point.X + point.Y * point.Y);
+		}
+
+		extension<T>(IEnumerable<T> @this)
+		{
+			public bool IsEmpty => !@this.Any();
+		}
+
+		extension(string @this)
+		{
+			public int WordCount => Regex.Matches(@this, @"\w+").Count;
+		}
 	}
 
 	internal class ExtensionEverythingTestUseSites

ICSharpCode.Decompiler/CSharp/CSharpDecompiler.cs

@@ -274,7 +274,7 @@ namespace ICSharpCode.Decompiler.CSharp
 		/// </summary>
 		/// <param name="module">The module containing the member.</param>
 		/// <param name="member">The metadata token/handle of the member. Can be a TypeDef, MethodDef or FieldDef.</param>
-		/// <param name="settings">THe settings used to determine whether code should be hidden. E.g. if async methods are not transformed, async state machines are included in the decompiled code.</param>
+		/// <param name="settings">The settings used to determine whether code should be hidden. E.g. if async methods are not transformed, async state machines are included in the decompiled code.</param>
 		public static bool MemberIsHidden(MetadataFile module, EntityHandle member, DecompilerSettings settings)
 		{
 			if (module == null || member.IsNil)
@@ -295,7 +295,7 @@ namespace ICSharpCode.Decompiler.CSharp
 					if (settings.LocalFunctions && LocalFunctionDecompiler.IsLocalFunctionMethod(module, methodHandle))
 						return true;
 					if (settings.AnonymousMethods && methodHandle.HasGeneratedName(metadata) && methodHandle.IsCompilerGenerated(metadata))
-						return true;
+						return name != "<Extension>$";
 					if (settings.AsyncAwait && AsyncAwaitDecompiler.IsCompilerGeneratedMainMethod(module, methodHandle))
 						return true;
 					return false;
@@ -319,7 +319,7 @@ namespace ICSharpCode.Decompiler.CSharp
 							return true;
 						if (settings.InlineArrays && name.StartsWith("<>y__InlineArray", StringComparison.Ordinal) && name.EndsWith("`1", StringComparison.Ordinal))
 							return true;
-						if (settings.ExtensionMembers && name.StartsWith("<>E__", StringComparison.Ordinal))
+						if (settings.ExtensionMembers && (name.StartsWith("<>E__", StringComparison.Ordinal) || name.StartsWith("<G>$", StringComparison.Ordinal)))
 							return true;
 					}
 					else if (type.IsCompilerGenerated(metadata))
@@ -506,6 +506,7 @@ namespace ICSharpCode.Decompiler.CSharp
 			typeSystemAstBuilder.SupportUnsignedRightShift = settings.UnsignedRightShift;
 			typeSystemAstBuilder.SupportOperatorChecked = settings.CheckedOperators;
 			typeSystemAstBuilder.AlwaysUseGlobal = settings.AlwaysUseGlobal;
+			typeSystemAstBuilder.SupportExtensionDeclarations = settings.ExtensionMembers;
 			return typeSystemAstBuilder;
 		}
 
@@ -726,6 +727,11 @@ namespace ICSharpCode.Decompiler.CSharp
 						continue;
 					try
 					{
+						if (TryGetExtensionImplementation(module.Metadata, part, out var impl))
+						{
+							connectedMethods.Enqueue(impl);
+						}
+
 						ReadCodeMappingInfo(module, info, parent, part, connectedMethods, processedNestedTypes);
 					}
 					catch (BadImageFormatException)
@@ -911,6 +917,51 @@ namespace ICSharpCode.Decompiler.CSharp
 			}
 		}
 
+		private static bool TryGetExtensionImplementation(MetadataReader metadata, MethodDefinitionHandle definitionPart, out MethodDefinitionHandle implementationPart)
+		{
+			implementationPart = default;
+
+			var def = metadata.GetMethodDefinition(definitionPart);
+			var declTypeHandle = def.GetDeclaringType();
+			var declType = metadata.GetTypeDefinition(declTypeHandle);
+			var name = metadata.GetString(def.Name);
+			var containerHandle = declType.GetDeclaringType();
+
+			if (containerHandle.IsNil)
+				return false;
+
+			if (metadata.StringComparer.StartsWith(declType.Name, "<>E__") || metadata.StringComparer.StartsWith(declType.Name, "<G>$"))
+			{
+				implementationPart = FindImplementations(metadata.GetTypeDefinition(containerHandle).GetMethods());
+			}
+			else if (metadata.StringComparer.StartsWith(declType.Name, "<M>$"))
+			{
+				var container = metadata.GetTypeDefinition(containerHandle);
+				var groupHandle = container.GetDeclaringType();
+				if (groupHandle.IsNil)
+					return false;
+
+				implementationPart = FindImplementations(metadata.GetTypeDefinition(groupHandle).GetMethods());
+			}
+			else
+			{
+				return false;
+			}
+
+			return !implementationPart.IsNil;
+
+			MethodDefinitionHandle FindImplementations(MethodDefinitionHandleCollection methods)
+			{
+				foreach (var h in methods)
+				{
+					var m = metadata.GetMethodDefinition(h);
+					if (metadata.StringComparer.Equals(m.Name, name))
+						return h;
+				}
+				return default;
+			}
+		}
+
 		/// <summary>
 		/// Decompiles the whole module into a single string.
 		/// </summary>
@@ -1019,6 +1070,7 @@ namespace ICSharpCode.Decompiler.CSharp
 
 			bool first = true;
 			ITypeDefinition parentTypeDef = null;
+			ExtensionInfo parentExtensionInfo = null;
 
 			foreach (var entity in definitions)
 			{
@@ -1038,7 +1090,8 @@ namespace ICSharpCode.Decompiler.CSharp
 						break;
 					case HandleKind.MethodDefinition:
 						IMethod method = module.GetDefinition((MethodDefinitionHandle)entity);
-						syntaxTree.Members.Add(DoDecompile(method, decompileRun, new SimpleTypeResolveContext(method), null));
+						parentExtensionInfo = method.ResolveExtensionInfo();
+						syntaxTree.Members.Add(DoDecompile(method, decompileRun, new SimpleTypeResolveContext(method), parentExtensionInfo));
 						if (first)
 						{
 							parentTypeDef = method.DeclaringTypeDefinition;
@@ -1055,7 +1108,8 @@ namespace ICSharpCode.Decompiler.CSharp
 						break;
 					case HandleKind.PropertyDefinition:
 						IProperty property = module.GetDefinition((PropertyDefinitionHandle)entity);
-						syntaxTree.Members.Add(DoDecompile(property, decompileRun, new SimpleTypeResolveContext(property), null));
+						parentExtensionInfo = property.ResolveExtensionInfo();
+						syntaxTree.Members.Add(DoDecompile(property, decompileRun, new SimpleTypeResolveContext(property), parentExtensionInfo));
 						if (first)
 						{
 							parentTypeDef = property.DeclaringTypeDefinition;
@@ -1086,6 +1140,61 @@ namespace ICSharpCode.Decompiler.CSharp
 			return syntaxTree;
 		}
 
+		public SyntaxTree DecompileExtension(EntityHandle handle)
+		{
+			if (handle.IsNil)
+				throw new ArgumentNullException(nameof(handle));
+			syntaxTree = new SyntaxTree();
+			var namespaces = new HashSet<string>();
+			RequiredNamespaceCollector.CollectNamespaces(handle, module, namespaces);
+			var decompileRun = CreateDecompileRun(namespaces);
+
+			switch (handle.Kind)
+			{
+				case HandleKind.TypeDefinition:
+					ITypeDefinition typeDef = module.GetDefinition((TypeDefinitionHandle)handle);
+					syntaxTree.Members.Add(DoDecompile(typeDef, decompileRun, new SimpleTypeResolveContext(typeDef), asExtension: true));
+					RunTransforms(syntaxTree, decompileRun, new SimpleTypeResolveContext(typeDef));
+					break;
+				case HandleKind.MethodDefinition:
+					IMethod methodDef = module.GetDefinition((MethodDefinitionHandle)handle);
+					var extensionInfo = methodDef.ResolveExtensionInfo();
+					Debug.Assert(extensionInfo != null);
+					var memberInfo = extensionInfo.InfoOfExtensionMember((IMethod)methodDef.MemberDefinition).GetValueOrDefault();
+					var subst = new TypeParameterSubstitution(memberInfo.ExtensionGroupingTypeParameters, null);
+					methodDef = methodDef.Specialize(subst);
+					EntityDeclaration entity = DoDecompile(methodDef, decompileRun, new SimpleTypeResolveContext(methodDef), extensionInfo);
+					syntaxTree.Members.Add(entity);
+					RemoveAttribute(entity, KnownAttribute.ExtensionMarker);
+					RunTransforms(syntaxTree, decompileRun, new SimpleTypeResolveContext(methodDef.DeclaringTypeDefinition));
+					break;
+				case HandleKind.PropertyDefinition:
+					IProperty propDef = module.GetDefinition((PropertyDefinitionHandle)handle);
+					extensionInfo = propDef.ResolveExtensionInfo();
+					Debug.Assert(extensionInfo != null);
+					var accessor = propDef.Getter ?? propDef.Setter;
+					memberInfo = extensionInfo.InfoOfExtensionMember((IMethod)accessor.MemberDefinition).GetValueOrDefault();
+					subst = new TypeParameterSubstitution(memberInfo.ExtensionGroupingTypeParameters, null);
+					propDef = (IProperty)propDef.Specialize(subst);
+					EntityDeclaration prop = DoDecompile(propDef, decompileRun, new SimpleTypeResolveContext(propDef), extensionInfo);
+					syntaxTree.Members.Add(prop);
+					RemoveAttribute(prop, KnownAttribute.ExtensionMarker);
+					if (propDef.Getter != null)
+					{
+						RemoveAttribute(prop.GetChildByRole(PropertyDeclaration.GetterRole), KnownAttribute.ExtensionMarker);
+					}
+					if (propDef.Setter != null)
+					{
+						RemoveAttribute(prop.GetChildByRole(PropertyDeclaration.SetterRole), KnownAttribute.ExtensionMarker);
+					}
+					RunTransforms(syntaxTree, decompileRun, new SimpleTypeResolveContext(propDef.DeclaringTypeDefinition));
+					break;
+				default:
+					throw new NotSupportedException($"HandleKind {handle.Kind} is not supported!");
+			}
+			return syntaxTree;
+		}
+
 		ITypeDefinition FindCommonDeclaringTypeDefinition(ITypeDefinition a, ITypeDefinition b)
 		{
 			if (a == null || b == null)
@@ -1202,6 +1311,9 @@ namespace ICSharpCode.Decompiler.CSharp
 		/// <param name="member">The node of the member which new modifier state should be determined.</param>
 		void SetNewModifier(EntityDeclaration member)
 		{
+			if (member is ExtensionDeclaration)
+				return;
+
 			var entity = (IEntity)member.GetSymbol();
 			var lookup = new MemberLookup(entity.DeclaringTypeDefinition, entity.ParentModule);
 
@@ -1278,7 +1390,7 @@ namespace ICSharpCode.Decompiler.CSharp
 			}
 		}
 
-		EntityDeclaration DoDecompile(ITypeDefinition typeDef, DecompileRun decompileRun, ITypeResolveContext decompilationContext)
+		EntityDeclaration DoDecompile(ITypeDefinition typeDef, DecompileRun decompileRun, ITypeResolveContext decompilationContext, bool asExtension = false)
 		{
 			Debug.Assert(decompilationContext.CurrentTypeDefinition == typeDef);
 			var watch = System.Diagnostics.Stopwatch.StartNew();
@@ -1288,15 +1400,33 @@ namespace ICSharpCode.Decompiler.CSharp
 			try
 			{
 				typeSystemAstBuilder = CreateAstBuilder(decompileRun.Settings);
-				var entityDecl = typeSystemAstBuilder.ConvertEntity(typeDef);
+				EntityDeclaration entityDecl;
+				if (asExtension)
+				{
+					var extensionInfo = typeDef.DeclaringTypeDefinition?.ExtensionInfo ?? typeDef.DeclaringTypeDefinition?.DeclaringTypeDefinition?.ExtensionInfo;
+					Debug.Assert(extensionInfo != null);
+					extensionInfo.IsExtensionMarkerType(typeDef, out var extensionGroup);
+					entityDecl = typeSystemAstBuilder.ConvertExtension(extensionGroup);
+				}
+				else
+				{
+					entityDecl = typeSystemAstBuilder.ConvertEntity(typeDef);
+				}
+
 				if (entityDecl is DelegateDeclaration delegateDeclaration)
 				{
 					// Fix empty parameter names in delegate declarations
 					FixParameterNames(delegateDeclaration);
 				}
-				var typeDecl = entityDecl as TypeDeclaration;
-				if (typeDecl == null)
+
+				if (entityDecl is not TypeDeclaration typeDecl)
 				{
+					if (entityDecl is ExtensionDeclaration ext && settings.ExtensionMembers)
+					{
+						var extensionInfo = typeDef.DeclaringTypeDefinition.ExtensionInfo ?? typeDef.DeclaringTypeDefinition.DeclaringTypeDefinition.ExtensionInfo;
+						extensionInfo.IsExtensionMarkerType(typeDef, out var group);
+						DoDecompileExtensionMembers(ext, group.Marker, extensionInfo);
+					}
 					// e.g. DelegateDeclaration
 					return entityDecl;
 				}
@@ -1327,32 +1457,10 @@ namespace ICSharpCode.Decompiler.CSharp
 
 				if (settings.ExtensionMembers)
 				{
-					foreach (var group in typeDef.ExtensionInfo?.GetGroups() ?? [])
+					foreach (var group in typeDef.ExtensionInfo?.ExtensionGroups ?? [])
 					{
-						var ext = new ExtensionDeclaration();
-						ITypeParameter[] typeParameters = group.Key.TypeParameters;
-						var subst = new TypeParameterSubstitution(typeParameters, null);
-						ext.TypeParameters.AddRange(typeParameters.Select(tp => typeSystemAstBuilder.ConvertTypeParameter(tp)));
-						var marker = group.Key.Marker.Specialize(subst);
-						ext.ReceiverParameters.Add(typeSystemAstBuilder.ConvertParameter(marker.Parameters.Single()));
-						ext.Constraints.AddRange(typeParameters.Select(c => typeSystemAstBuilder.ConvertTypeParameterConstraint(c)));
-
-						foreach (var member in group)
-						{
-							IMember extMember = member.ExtensionMember.Specialize(subst);
-							if (member.ExtensionMember.IsAccessor)
-							{
-								extMember = member.ExtensionMember.AccessorOwner;
-							}
-							if (entityMap.Contains(extMember) || extMember.MetadataToken.IsNil)
-							{
-								// Member is already decompiled.
-								continue;
-							}
-							EntityDeclaration extMemberDecl = DoDecompileExtensionMember(extMember, typeDef.ExtensionInfo, decompileRun, decompilationContext);
-							ext.Members.Add(extMemberDecl);
-							entityMap.Add(extMember, extMemberDecl);
-						}
+						var ext = (ExtensionDeclaration)typeSystemAstBuilder.ConvertExtension(group);
+						DoDecompileExtensionMembers(ext, group.Marker, typeDef.ExtensionInfo);
 
 						typeDecl.Members.Add(ext);
 					}
@@ -1478,7 +1586,7 @@ namespace ICSharpCode.Decompiler.CSharp
 				{
 					switch (entity)
 					{
-						case ITypeDefinition td when extensionInfo.IsExtensionGroupingType(td):
+						case ITypeDefinition td when extensionInfo.IsExtensionGroupType(td) || extensionInfo.IsExtensionMarkerType(td, out _):
 							return;
 						case IMethod m when extensionInfo.InfoOfImplementationMember(m).HasValue:
 							return;
@@ -1549,31 +1657,45 @@ namespace ICSharpCode.Decompiler.CSharp
 					}
 				}
 			}
-		}
 
-		private EntityDeclaration DoDecompileExtensionMember(IMember extMember, ExtensionInfo info, DecompileRun decompileRun, ITypeResolveContext decompilationContext)
-		{
-			switch (extMember)
+			void DoDecompileExtensionMembers(ExtensionDeclaration ext, IMethod marker, ExtensionInfo extensionInfo)
 			{
-				case IProperty p:
-					var prop = DoDecompile(p, decompileRun, decompilationContext.WithCurrentMember(p), info);
-					RemoveAttribute(prop, KnownAttribute.ExtensionMarker);
-					if (p.Getter != null)
+				foreach (var member in extensionInfo.GetMembersOfGroup(marker))
+				{
+					var extMember = member;
+					if (entityMap.Contains(extMember) || extMember.MetadataToken.IsNil)
 					{
-						RemoveAttribute(prop.GetChildByRole(PropertyDeclaration.GetterRole), KnownAttribute.ExtensionMarker);
+						// Member is already decompiled.
+						continue;
 					}
-					if (p.Setter != null)
+					EntityDeclaration extMemberDecl;
+					switch (extMember)
 					{
-						RemoveAttribute(prop.GetChildByRole(PropertyDeclaration.SetterRole), KnownAttribute.ExtensionMarker);
+						case IProperty p:
+							var prop = DoDecompile(p, decompileRun, decompilationContext.WithCurrentMember(p), extensionInfo);
+							RemoveAttribute(prop, KnownAttribute.ExtensionMarker);
+							if (p.Getter != null)
+							{
+								RemoveAttribute(prop.GetChildByRole(PropertyDeclaration.GetterRole), KnownAttribute.ExtensionMarker);
+							}
+							if (p.Setter != null)
+							{
+								RemoveAttribute(prop.GetChildByRole(PropertyDeclaration.SetterRole), KnownAttribute.ExtensionMarker);
+							}
+							extMemberDecl = prop;
+							break;
+						case IMethod m:
+							var meth = DoDecompile(m, decompileRun, decompilationContext.WithCurrentMember(m), extensionInfo);
+							RemoveAttribute(meth, KnownAttribute.ExtensionMarker);
+							extMemberDecl = meth;
+							break;
+						default:
+							throw new NotSupportedException($"Extension member {extMember} is not supported for decompilation.");
 					}
-					return prop;
-				case IMethod m:
-					var meth = DoDecompile(m, decompileRun, decompilationContext.WithCurrentMember(m), info);
-					RemoveAttribute(meth, KnownAttribute.ExtensionMarker);
-					return meth;
+					ext.Members.Add(extMemberDecl);
+					entityMap.Add(extMember, extMemberDecl);
+				}
 			}
-
-			throw new NotSupportedException($"Extension member {extMember} is not supported for decompilation.");
 		}
 
 		EnumValueDisplayMode DetectBestEnumValueDisplayMode(ITypeDefinition typeDef, MetadataFile module)

ICSharpCode.Decompiler/CSharp/OutputVisitor/CSharpAmbience.cs

@@ -58,6 +58,15 @@ namespace ICSharpCode.Decompiler.CSharp.OutputVisitor
 				throw new ArgumentNullException(nameof(formattingPolicy));
 
 			TypeSystemAstBuilder astBuilder = CreateAstBuilder();
+
+			if (IsExtension(symbol as ITypeDefinition, out var extensionGroup))
+			{
+				astBuilder.ShowParameterNames = true;
+			}
+			else
+			{
+				extensionGroup = default;
+			}
 			AstNode node = astBuilder.ConvertSymbol(symbol);
 			writer.StartNode(node);
 			if (node is EntityDeclaration entityDecl)
@@ -129,11 +138,21 @@ namespace ICSharpCode.Decompiler.CSharp.OutputVisitor
 			else
 				writer.WriteIdentifier(Identifier.Create(symbol.Name));
 
-			if ((ConversionFlags & ConversionFlags.ShowParameterList) == ConversionFlags.ShowParameterList && HasParameters(symbol))
+			if (ShowParameterList(symbol))
 			{
 				writer.WriteToken(symbol.SymbolKind == SymbolKind.Indexer ? Roles.LBracket : Roles.LPar, symbol.SymbolKind == SymbolKind.Indexer ? "[" : "(");
 				bool first = true;
-				foreach (var param in node.GetChildrenByRole(Roles.Parameter))
+				IEnumerable<ParameterDeclaration> parameters;
+				if (extensionGroup.Marker != null)
+				{
+					var subst = new TypeParameterSubstitution(extensionGroup.TypeParameters, null);
+					parameters = extensionGroup.Marker.Specialize(subst).Parameters.Select(p => astBuilder.ConvertParameter(p));
+				}
+				else
+				{
+					parameters = node.GetChildrenByRole(Roles.Parameter);
+				}
+				foreach (var param in parameters)
 				{
 					if ((ConversionFlags & ConversionFlags.ShowParameterModifiers) == 0)
 					{
@@ -213,18 +232,31 @@ namespace ICSharpCode.Decompiler.CSharp.OutputVisitor
 			}
 		}
 
-		static bool HasParameters(ISymbol e)
+		bool IsExtension(ITypeDefinition? typeDef, out (IMethod Marker, IReadOnlyList<ITypeParameter> TypeParameters) extensionGroup)
+		{
+			extensionGroup = default;
+			if ((ConversionFlags & ConversionFlags.SupportExtensionDeclarations) == 0)
+				return false;
+			if (typeDef == null)
+				return false;
+			var extensionInfo = typeDef.DeclaringTypeDefinition?.ExtensionInfo ?? typeDef.DeclaringTypeDefinition?.DeclaringTypeDefinition?.ExtensionInfo;
+			return extensionInfo != null && extensionInfo.IsExtensionMarkerType(typeDef, out extensionGroup);
+		}
+
+		bool ShowParameterList(ISymbol e)
 		{
 			switch (e.SymbolKind)
 			{
-				case SymbolKind.TypeDefinition:
-					return ((ITypeDefinition)e).Kind == TypeKind.Delegate;
+				case SymbolKind.TypeDefinition when ((ITypeDefinition)e).Kind is TypeKind.Delegate:
+					return (ConversionFlags & ConversionFlags.ShowParameterList) != 0;
+				case SymbolKind.TypeDefinition when IsExtension((ITypeDefinition)e, out _):
+					return (ConversionFlags & ConversionFlags.SupportExtensionDeclarations) != 0;
 				case SymbolKind.Indexer:
 				case SymbolKind.Method:
 				case SymbolKind.Operator:
 				case SymbolKind.Constructor:
 				case SymbolKind.Destructor:
-					return true;
+					return (ConversionFlags & ConversionFlags.ShowParameterList) != 0;
 				default:
 					return false;
 			}
@@ -246,6 +278,7 @@ namespace ICSharpCode.Decompiler.CSharp.OutputVisitor
 			astBuilder.SupportRecordStructs = (ConversionFlags & ConversionFlags.SupportRecordStructs) != 0;
 			astBuilder.SupportUnsignedRightShift = (ConversionFlags & ConversionFlags.SupportUnsignedRightShift) != 0;
 			astBuilder.SupportOperatorChecked = (ConversionFlags & ConversionFlags.SupportOperatorChecked) != 0;
+			astBuilder.SupportExtensionDeclarations = (ConversionFlags & ConversionFlags.SupportExtensionDeclarations) != 0;
 			return astBuilder;
 		}
 
@@ -268,8 +301,16 @@ namespace ICSharpCode.Decompiler.CSharp.OutputVisitor
 					writer.WriteToken(Roles.Dot, ".");
 				}
 			}
-			writer.WriteIdentifier(node.NameToken);
-			WriteTypeParameters(node, writer, formattingPolicy);
+			if (IsExtension(typeDef, out var group))
+			{
+				writer.WriteKeyword(ExtensionDeclaration.ExtensionKeywordRole, "extension");
+				WriteTypeParameters(group.TypeParameters.Select(tp => astBuilder.ConvertTypeParameter(tp)), writer, formattingPolicy);
+			}
+			else
+			{
+				writer.WriteIdentifier(node.NameToken);
+				WriteTypeParameters(node.GetChildrenByRole(Roles.TypeParameter), writer, formattingPolicy);
+			}
 		}
 
 		void WriteMemberDeclarationName(IMember member, TokenWriter writer, CSharpFormattingOptions formattingPolicy)
@@ -371,15 +412,14 @@ namespace ICSharpCode.Decompiler.CSharp.OutputVisitor
 					writer.WriteIdentifier(Identifier.Create(name));
 					break;
 			}
-			WriteTypeParameters(node, writer, formattingPolicy);
+			WriteTypeParameters(node.GetChildrenByRole(Roles.TypeParameter), writer, formattingPolicy);
 		}
 
-		void WriteTypeParameters(EntityDeclaration node, TokenWriter writer, CSharpFormattingOptions formattingPolicy)
+		void WriteTypeParameters(IEnumerable<TypeParameterDeclaration> typeParameters, TokenWriter writer, CSharpFormattingOptions formattingPolicy)
 		{
 			if ((ConversionFlags & ConversionFlags.ShowTypeParameterList) == ConversionFlags.ShowTypeParameterList)
 			{
 				var outputVisitor = new CSharpOutputVisitor(writer, formattingPolicy);
-				IEnumerable<TypeParameterDeclaration> typeParameters = node.GetChildrenByRole(Roles.TypeParameter);
 				if ((ConversionFlags & ConversionFlags.ShowTypeParameterVarianceModifier) == 0)
 				{
 					typeParameters = typeParameters.Select(RemoveVarianceModifier);

ICSharpCode.Decompiler/CSharp/RequiredNamespaceCollector.cs

@@ -65,6 +65,12 @@ namespace ICSharpCode.Decompiler.CSharp
 			switch (entity)
 			{
 				case ITypeDefinition td:
+					var extensionInfo = td.DeclaringTypeDefinition?.ExtensionInfo ?? td.DeclaringTypeDefinition?.DeclaringTypeDefinition?.ExtensionInfo;
+					if (extensionInfo?.IsExtensionMarkerType(td, out _) == true || extensionInfo?.IsExtensionGroupType(td) == true)
+					{
+						td = extensionInfo.Container;
+					}
+
 					namespaces.Add(td.Namespace);
 					HandleAttributes(td.GetAttributes());
 					HandleTypeParameters(td.TypeParameters);
@@ -76,6 +82,9 @@ namespace ICSharpCode.Decompiler.CSharp
 
 					foreach (var nestedType in td.NestedTypes)
 					{
+						bool isGroupOrMarker = extensionInfo?.IsExtensionGroupType(nestedType) == true || extensionInfo?.IsExtensionMarkerType(nestedType, out _) == true;
+						if (isGroupOrMarker)
+							continue;
 						CollectNamespaces(nestedType, module, mappingInfo);
 					}
 

ICSharpCode.Decompiler/CSharp/Syntax/TypeSystemAstBuilder.cs

@@ -252,6 +252,11 @@ namespace ICSharpCode.Decompiler.CSharp.Syntax
 		/// Controls whether all fully qualified type names should be prefixed with "global::".
 		/// </summary>
 		public bool AlwaysUseGlobal { get; set; }
+
+		/// <summary>
+		/// Controls whether C# 14 "extension" declarations are supported.
+		/// </summary>
+		public bool SupportExtensionDeclarations { get; set; }
 		#endregion
 
 		#region Convert Type
@@ -1812,6 +1817,16 @@ namespace ICSharpCode.Decompiler.CSharp.Syntax
 			}
 		}
 
+		public EntityDeclaration ConvertExtension((IMethod MarkerMethod, IReadOnlyList<ITypeParameter> TypeParameters) group)
+		{
+			var ext = new ExtensionDeclaration();
+			var subst = new TypeParameterSubstitution(group.TypeParameters, []);
+			ext.TypeParameters.AddRange(group.TypeParameters.Select(ConvertTypeParameter));
+			ext.ReceiverParameters.Add(ConvertParameter(group.MarkerMethod.Specialize(subst).Parameters.Single()));
+			ext.Constraints.AddRange(group.TypeParameters.Select(ConvertTypeParameterConstraint));
+			return ext;
+		}
+
 		EntityDeclaration ConvertTypeDefinition(ITypeDefinition typeDefinition)
 		{
 			Modifiers modifiers = Modifiers.None;

ICSharpCode.Decompiler/ICSharpCode.Decompiler.csproj

@@ -28,7 +28,7 @@
     <GenerateAssemblyInformationalVersionAttribute>False</GenerateAssemblyInformationalVersionAttribute>
 
     <EnableDefaultItems>false</EnableDefaultItems>
-    <LangVersion>13</LangVersion>
+    <LangVersion>14</LangVersion>
     <GenerateDocumentationFile>true</GenerateDocumentationFile>
     <SignAssembly>True</SignAssembly>
     <AssemblyOriginatorKeyFile>ICSharpCode.Decompiler.snk</AssemblyOriginatorKeyFile>

ICSharpCode.Decompiler/IL/Transforms/TransformDisplayClassUsage.cs

@@ -53,7 +53,7 @@ namespace ICSharpCode.Decompiler.IL.Transforms
 			private readonly IField field;
 			private ILVariable declaredVariable;
 
-			public string Name => field.Name;
+			public string Name => @field.Name;
 
 			public bool CanPropagate { get; private set; }
 			public bool UsesInitialValue { get; set; }

ICSharpCode.Decompiler/Output/IAmbience.cs

@@ -121,6 +121,10 @@ namespace ICSharpCode.Decompiler.Output
 		/// Support C# 7.2 <c>private protected</c>.
 		/// </summary>
 		UsePrivateProtectedAccessibility = 0x200000,
+		/// <summary>
+		/// Support C# 14 <c>extension</c> declarations.
+		/// </summary>
+		SupportExtensionDeclarations = 0x400000,
 
 		StandardConversionFlags = ShowParameterNames |
 			ShowAccessibility |

ICSharpCode.Decompiler/Output/TextTokenWriter.cs

@@ -243,6 +243,22 @@ namespace ICSharpCode.Decompiler
 			output.Write(keyword);
 		}
 
+		static bool NeedsFold(AstNode node)
+		{
+			if (node == null)
+			{
+				return false;
+			}
+
+			if (node is EntityDeclaration)
+				return true;
+
+			if (node is BlockStatement { Parent: EntityDeclaration or LocalFunctionDeclarationStatement or AnonymousMethodExpression or LambdaExpression })
+				return true;
+
+			return false;
+		}
+
 		public override void WriteToken(Role role, string token)
 		{
 			switch (token)
@@ -255,17 +271,15 @@ namespace ICSharpCode.Decompiler
 					}
 					if (braceLevelWithinType >= 0 || nodeStack.Peek() is TypeDeclaration)
 						braceLevelWithinType++;
-					if (nodeStack.PeekOrDefault() is TypeDeclaration or ExtensionDeclaration or BlockStatement { Parent: EntityDeclaration or LocalFunctionDeclarationStatement or AnonymousMethodExpression or LambdaExpression } || settings.FoldBraces)
-					{
+					if (NeedsFold(nodeStack.PeekOrDefault()) || settings.FoldBraces)
 						output.MarkFoldStart(defaultCollapsed: !settings.ExpandMemberDefinitions && braceLevelWithinType == 1, isDefinition: braceLevelWithinType == 1);
-					}
 					output.Write("{");
 					break;
 				case "}":
 					output.Write('}');
 					if (role != Roles.RBrace)
 						break;
-					if (nodeStack.PeekOrDefault() is TypeDeclaration or ExtensionDeclaration or BlockStatement { Parent: EntityDeclaration or LocalFunctionDeclarationStatement or AnonymousMethodExpression or LambdaExpression } || settings.FoldBraces)
+					if (NeedsFold(nodeStack.PeekOrDefault()) || settings.FoldBraces)
 						output.MarkFoldEnd();
 					if (braceLevelWithinType >= 0)
 						braceLevelWithinType--;

ICSharpCode.Decompiler/TypeSystem/DecompilerTypeSystem.cs

@@ -150,12 +150,16 @@ namespace ICSharpCode.Decompiler.TypeSystem
 		/// </summary>
 		FirstClassSpanTypes = 0x40000,
 		/// <summary>
+		/// If this option is active, extension member groups are detected, otherwise the compiler-generated nested classes are left as-is.
+		/// </summary>
+		ExtensionMembers = 0x80000,
+		/// <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
+			| RefReadOnlyParameters | ParamsCollections | FirstClassSpanTypes | ExtensionMembers
 	}
 
 	/// <summary>
@@ -201,6 +205,8 @@ namespace ICSharpCode.Decompiler.TypeSystem
 				typeSystemOptions |= TypeSystemOptions.ParamsCollections;
 			if (settings.FirstClassSpanTypes)
 				typeSystemOptions |= TypeSystemOptions.FirstClassSpanTypes;
+			if (settings.ExtensionMembers)
+				typeSystemOptions |= TypeSystemOptions.ExtensionMembers;
 			return typeSystemOptions;
 		}
 

ICSharpCode.Decompiler/TypeSystem/ExtensionInfo.cs

@@ -25,6 +25,7 @@ using System.Linq;
 using System.Reflection.Metadata;
 
 using ICSharpCode.Decompiler.TypeSystem.Implementation;
+using ICSharpCode.Decompiler.Util;
 
 namespace ICSharpCode.Decompiler.TypeSystem
 {
@@ -32,11 +33,14 @@ namespace ICSharpCode.Decompiler.TypeSystem
 	{
 		readonly Dictionary<IMember, ExtensionMemberInfo> extensionMemberMap;
 		readonly Dictionary<IMember, ExtensionMemberInfo> implementationMemberMap;
+		readonly List<(IMethod Marker, IReadOnlyList<ITypeParameter> TypeParameters)> extensionGroups;
 
 		public ExtensionInfo(MetadataModule module, ITypeDefinition extensionContainer)
 		{
 			this.extensionMemberMap = new();
 			this.implementationMemberMap = new();
+			this.extensionGroups = [];
+			this.Container = extensionContainer;
 
 			var metadata = module.MetadataFile.Metadata;
 
@@ -86,7 +90,9 @@ namespace ICSharpCode.Decompiler.TypeSystem
 				if (marker == null || hasMultipleMarkers)
 					return false;
 
-				CollectImplementationMethods(extGroup, marker, extensionMethods, extensionGroupTypeParameters);
+				extensionGroups.Add((marker, extensionGroupTypeParameters));
+
+				CollectImplementationMethods(marker, extensionGroupTypeParameters, extensionMethods);
 				return true;
 			}
 
@@ -111,9 +117,19 @@ namespace ICSharpCode.Decompiler.TypeSystem
 					if (marker == null)
 						continue;
 
+					ITypeParameter[] extensionGroupTypeParameters = new ITypeParameter[markerType.TypeParameterCount];
+					var markerTypeTypeParameters = metadata.GetTypeDefinition((TypeDefinitionHandle)markerType.MetadataToken).GetGenericParameters();
+
+					foreach (var h in markerTypeTypeParameters.WithIndex())
+					{
+						var tp = metadata.GetGenericParameter(h.Item2);
+						extensionGroupTypeParameters[h.Item1] = MetadataTypeParameter.Create(module, markerType, h.Item1, h.Item2);
+					}
+
+					extensionGroups.Add((marker, extensionGroupTypeParameters));
+
 					TypeDefinition td = metadata.GetTypeDefinition((TypeDefinitionHandle)extensionGroupsContainer.MetadataToken);
 					List<IMethod> extensionMethods = [];
-					ITypeParameter[] extensionGroupTypeParameters = new ITypeParameter[extensionGroupsContainer.TypeParameterCount];
 
 					// For easier access to accessors we use SRM
 					foreach (var h in td.GetMethods())
@@ -133,25 +149,24 @@ namespace ICSharpCode.Decompiler.TypeSystem
 						extensionMethods.Add(method);
 					}
 
-					CollectImplementationMethods(extensionGroupsContainer, marker, extensionMethods, extensionGroupTypeParameters);
+					CollectImplementationMethods(marker, extensionGroupTypeParameters, extensionMethods);
 				}
 
 				return true;
 			}
 
-			void CollectImplementationMethods(ITypeDefinition extGroup, IMethod marker, List<IMethod> extensionMethods, ITypeParameter[] extensionGroupTypeParameters)
+			void CollectImplementationMethods(IMethod marker, IReadOnlyList<ITypeParameter> typeParameters, List<IMethod> extensionMethods)
 			{
+				ITypeDefinition markerType = marker.DeclaringTypeDefinition!;
 				List<(IMethod extension, IMethod implementation)> implementations = [];
 
-				string[] typeParameterNames = new string[extGroup.TypeParameterCount];
-
 				foreach (var extension in extensionMethods)
 				{
-					int expectedTypeParameterCount = extension.TypeParameters.Count + extGroup.TypeParameterCount;
+					int expectedTypeParameterCount = extension.TypeParameters.Count + markerType.TypeParameterCount;
 					bool hasInstance = !extension.IsStatic;
 					int parameterOffset = hasInstance ? 1 : 0;
 					int expectedParameterCount = extension.Parameters.Count + parameterOffset;
-					TypeParameterSubstitution subst = new TypeParameterSubstitution([], [.. extGroup.TypeArguments, .. extension.TypeArguments]);
+					TypeParameterSubstitution subst = new TypeParameterSubstitution([], [.. markerType.TypeArguments, .. extension.TypeArguments]);
 
 					bool IsMatchingImplementation(IMethod impl)
 					{
@@ -200,48 +215,15 @@ namespace ICSharpCode.Decompiler.TypeSystem
 
 				foreach (var (extension, implementation) in implementations)
 				{
-					for (int i = 0; i < extensionGroupTypeParameters.Length; i++)
-					{
-						if (typeParameterNames[i] == null)
-						{
-							typeParameterNames[i] = implementation.TypeParameters[i].Name;
-						}
-						else if (typeParameterNames[i] != implementation.TypeParameters[i].Name)
-						{
-							// TODO: Handle name conflicts properly
-							typeParameterNames[i] = $"T{i + 1}";
-						}
-					}
-				}
-
-				for (int i = 0; i < extensionGroupTypeParameters.Length; i++)
-				{
-					var originalTypeParameter = extGroup.TypeParameters[i];
-					if (extensionGroupTypeParameters[i] == null)
-					{
-						extensionGroupTypeParameters[i] = new DefaultTypeParameter(
-							extGroup, i, typeParameterNames[i],
-							VarianceModifier.Invariant,
-							attributes: originalTypeParameter.GetAttributes().ToArray(),
-							originalTypeParameter.HasValueTypeConstraint,
-							originalTypeParameter.HasReferenceTypeConstraint,
-							originalTypeParameter.HasDefaultConstructorConstraint,
-							originalTypeParameter.TypeConstraints.Select(c => c.Type).ToArray(),
-							originalTypeParameter.NullabilityConstraint
-						);
-					}
-				}
-
-				foreach (var (extension, implementation) in implementations)
-				{
-					var info = new ExtensionMemberInfo(marker, extension, implementation, extensionGroupTypeParameters);
+					var info = new ExtensionMemberInfo(marker, typeParameters, extension, implementation);
 					this.extensionMemberMap[extension] = info;
 					this.implementationMemberMap[implementation] = info;
 				}
-
 			}
 		}
 
+		public ITypeDefinition Container { get; }
+
 		public ExtensionMemberInfo? InfoOfExtensionMember(IMethod method)
 		{
 			return this.extensionMemberMap.TryGetValue(method, out var value) ? value : null;
@@ -252,18 +234,49 @@ namespace ICSharpCode.Decompiler.TypeSystem
 			return this.implementationMemberMap.TryGetValue(method, out var value) ? value : null;
 		}
 
-		public IEnumerable<IGrouping<(IMethod Marker, ITypeParameter[] TypeParameters), ExtensionMemberInfo>> GetGroups()
+		public bool IsExtensionGroupType(ITypeDefinition td)
 		{
-			return this.extensionMemberMap.Values.GroupBy(x => (x.ExtensionMarkerMethod, x.ExtensionGroupingTypeParameters));
+			return this.extensionGroups.Any(m => m.Marker.DeclaringTypeDefinition?.DeclaringTypeDefinition?.Equals(td) == true);
 		}
 
-		public bool IsExtensionGroupingType(ITypeDefinition type)
+		public bool IsExtensionMarkerType(ITypeDefinition td, out (IMethod Marker, IReadOnlyList<ITypeParameter> TypeParameters) extensionGroup)
 		{
-			return this.extensionMemberMap.Values.Any(x => x.ExtensionGroupingType.Equals(type));
+			extensionGroup = default;
+			foreach (var group in this.extensionGroups)
+			{
+				if (group.Marker.DeclaringTypeDefinition?.Equals(td) == true)
+				{
+					extensionGroup = group;
+					return true;
+				}
+			}
+			return false;
 		}
+
+		public IEnumerable<IMember> GetMembersOfGroup(IMethod marker)
+		{
+			return GetMembers().Distinct();
+
+			IEnumerable<IMember> GetMembers()
+			{
+				var markerType = marker.DeclaringTypeDefinition;
+				foreach (var info in extensionMemberMap.Values)
+				{
+					if (!markerType!.Equals(info.ExtensionMarkerType))
+						continue;
+					var subst = new TypeParameterSubstitution(info.ExtensionGroupingTypeParameters, null);
+					if (info.ExtensionMember.IsAccessor)
+						yield return info.ExtensionMember.AccessorOwner.Specialize(subst);
+					else
+						yield return info.ExtensionMember.Specialize(subst);
+				}
+			}
+		}
+
+		public IReadOnlyList<(IMethod Marker, IReadOnlyList<ITypeParameter> TypeParameters)> ExtensionGroups => this.extensionGroups;
 	}
 
-	public readonly struct ExtensionMemberInfo(IMethod marker, IMethod extension, IMethod implementation, ITypeParameter[] extensionGroupingTypeParameters)
+	public readonly struct ExtensionMemberInfo(IMethod marker, IReadOnlyList<ITypeParameter> typeParameters, IMethod extension, IMethod implementation)
 	{
 		/// <summary>
 		/// Metadata-only method called '&lt;Extension&gt;$'. Has the C# signature for the extension declaration.
@@ -282,6 +295,11 @@ namespace ICSharpCode.Decompiler.TypeSystem
 		/// </summary>
 		public readonly IMethod ImplementationMethod = implementation;
 
+		/// <summary>
+		/// This is the array of type parameters for the extension declaration.
+		/// </summary>
+		public readonly IReadOnlyList<ITypeParameter> ExtensionGroupingTypeParameters = typeParameters;
+
 		/// <summary>
 		/// This is the enclosing static class.
 		/// </summary>
@@ -293,11 +311,6 @@ namespace ICSharpCode.Decompiler.TypeSystem
 		/// </summary>
 		public ITypeDefinition ExtensionGroupingType => ExtensionMember.DeclaringTypeDefinition!;
 
-		/// <summary>
-		/// This is the array of type parameters for the extension declaration.
-		/// </summary>
-		public ITypeParameter[] ExtensionGroupingTypeParameters => extensionGroupingTypeParameters;
-
 		/// <summary>
 		/// This class holds the type parameters for the extension declaration with full fidelity of C# constraints.
 		/// </summary>

ICSharpCode.Decompiler/TypeSystem/IMethod.cs

@@ -66,6 +66,9 @@ namespace ICSharpCode.Decompiler.TypeSystem
 		/// </summary>
 		IReadOnlyList<IType> TypeArguments { get; }
 
+		/// <summary>
+		/// Returns true for classic extension methods, where extension method == implementation method, otherwise returns false.
+		/// </summary>
 		bool IsExtensionMethod { get; }
 		bool IsLocalFunction { get; }
 		bool IsConstructor { get; }

ICSharpCode.Decompiler/TypeSystem/ITypeDefinition.cs

@@ -28,7 +28,6 @@ namespace ICSharpCode.Decompiler.TypeSystem
 	/// </summary>
 	public interface ITypeDefinition : ITypeDefinitionOrUnknown, IType, IEntity
 	{
-		ExtensionInfo? ExtensionInfo { get; }
 		IReadOnlyList<ITypeDefinition> NestedTypes { get; }
 		IReadOnlyList<IMember> Members { get; }
 
@@ -77,6 +76,13 @@ namespace ICSharpCode.Decompiler.TypeSystem
 		/// <remarks>This property is used to speed up the search for extension members.</remarks>
 		bool HasExtensions { get; }
 
+		/// <summary>
+		/// For types containing extension blocks, returns a non-null value.
+		/// For extension blocks, returns the extension info of the parent.
+		/// For all other types returns null.
+		/// </summary>
+		ExtensionInfo? ExtensionInfo { get; }
+
 		/// <summary>
 		/// The nullability specified in the [NullableContext] attribute on the type.
 		/// This serves as default nullability for members of the type that do not have a [Nullable] attribute.

ICSharpCode.Decompiler/TypeSystem/Implementation/MetadataTypeDefinition.cs

@@ -150,6 +150,8 @@ namespace ICSharpCode.Decompiler.TypeSystem.Implementation
 			get {
 				if (!HasExtensions)
 					return null;
+				if ((module.TypeSystemOptions & TypeSystemOptions.ExtensionMembers) == 0)
+					return null;
 				var extensionInfo = LazyInit.VolatileRead(ref this.extensionInfo);
 				if (extensionInfo != null)
 					return extensionInfo;
@@ -203,8 +205,8 @@ namespace ICSharpCode.Decompiler.TypeSystem.Implementation
 				var fieldList = new List<IField>(fieldCollection.Count);
 				foreach (FieldDefinitionHandle h in fieldCollection)
 				{
-					var field = metadata.GetFieldDefinition(h);
-					var attr = field.Attributes;
+					var @field = metadata.GetFieldDefinition(h);
+					var attr = @field.Attributes;
 					if (module.IsVisible(attr))
 					{
 						fieldList.Add(module.GetDefinition(h));

ICSharpCode.Decompiler/TypeSystem/TypeSystemExtensions.cs

@@ -871,5 +871,15 @@ namespace ICSharpCode.Decompiler.TypeSystem
 			}
 			return ns;
 		}
+
+		public static ExtensionInfo? ResolveExtensionInfo(this IMember member)
+		{
+			if (member is null)
+			{
+				throw new ArgumentNullException(nameof(member));
+			}
+			var td = member.DeclaringTypeDefinition!;
+			return td.DeclaringTypeDefinition?.ExtensionInfo ?? td.DeclaringTypeDefinition?.DeclaringTypeDefinition?.ExtensionInfo;
+		}
 	}
 }

ILSpy/ExtensionMethods.cs

@@ -76,7 +76,7 @@ namespace ICSharpCode.ILSpy
 			return result;
 		}
 
-		public static ICompilation? GetTypeSystemWithCurrentOptionsOrNull(this MetadataFile file, SettingsService settingsService, LanguageVersion languageVersion)
+		public static ICompilation? GetTypeSystemWithCurrentOptionsOrNull(this MetadataFile file, SettingsService settingsService, LanguageVersion? languageVersion)
 		{
 			var decompilerSettings = settingsService.DecompilerSettings.Clone();
 			if (!Enum.TryParse(languageVersion?.Version, out Decompiler.CSharp.LanguageVersion csharpLanguageVersion))

ILSpy/Images/Images.cs

@@ -258,11 +258,13 @@ namespace ICSharpCode.ILSpy
 			{
 				var extensionGroup = new DrawingGroup();
 				extensionGroup.Children.Add(baseDrawingGroup);
-				baseDrawingGroup.Transform = new ScaleTransform(0.8, 8.0);
+				baseDrawingGroup.Transform = new ScaleTransform(0.8, 0.8);
 				extensionGroup.Children.Add(new ImageDrawing(Images.OverlayExtension, iconRect));
 				baseDrawingGroup = extensionGroup;
 			}
 
+			group.Children.Add(baseDrawingGroup);
+
 			if (isStatic)
 			{
 				group.Children.Add(new ImageDrawing(Images.OverlayStatic, iconRect));
@@ -274,8 +276,6 @@ namespace ICSharpCode.ILSpy
 				group.Children.Add(new ImageDrawing(overlay, iconRect));
 			}
 
-			group.Children.Add(baseDrawingGroup);
-
 			var image = new DrawingImage(group);
 			if (image.CanFreeze)
 			{

ILSpy/Languages/CSharpLanguage.cs

@@ -364,6 +364,39 @@ namespace ICSharpCode.ILSpy
 			WriteCode(output, options.DecompilerSettings, decompiler.Decompile(type.MetadataToken), decompiler.TypeSystem);
 		}
 
+		public void DecompileExtension(ITypeDefinition extension, ITextOutput output, DecompilationOptions options)
+		{
+			MetadataFile assembly = extension.ParentModule.MetadataFile;
+			CSharpDecompiler decompiler = CreateDecompiler(assembly, options);
+			AddReferenceAssemblyWarningMessage(assembly, output);
+			AddReferenceWarningMessage(assembly, output);
+			WriteCommentLine(output, assembly.FullName);
+			WriteCommentLine(output, TypeToString(extension, ConversionFlags.UseFullyQualifiedTypeNames | ConversionFlags.UseFullyQualifiedEntityNames | ConversionFlags.SupportExtensionDeclarations));
+			WriteCode(output, options.DecompilerSettings, decompiler.DecompileExtension(extension.MetadataToken), decompiler.TypeSystem);
+		}
+
+		public void DecompileExtension(IMethod extension, ITextOutput output, DecompilationOptions options)
+		{
+			MetadataFile assembly = extension.ParentModule.MetadataFile;
+			CSharpDecompiler decompiler = CreateDecompiler(assembly, options);
+			AddReferenceAssemblyWarningMessage(assembly, output);
+			AddReferenceWarningMessage(assembly, output);
+			WriteCommentLine(output, assembly.FullName);
+			WriteCommentLine(output, TypeToString(extension.DeclaringType, ConversionFlags.UseFullyQualifiedTypeNames | ConversionFlags.UseFullyQualifiedEntityNames | ConversionFlags.SupportExtensionDeclarations));
+			WriteCode(output, options.DecompilerSettings, decompiler.DecompileExtension(extension.MetadataToken), decompiler.TypeSystem);
+		}
+
+		public void DecompileExtension(IProperty extension, ITextOutput output, DecompilationOptions options)
+		{
+			MetadataFile assembly = extension.ParentModule.MetadataFile;
+			CSharpDecompiler decompiler = CreateDecompiler(assembly, options);
+			AddReferenceAssemblyWarningMessage(assembly, output);
+			AddReferenceWarningMessage(assembly, output);
+			WriteCommentLine(output, assembly.FullName);
+			WriteCommentLine(output, TypeToString(extension.DeclaringType, ConversionFlags.UseFullyQualifiedTypeNames | ConversionFlags.UseFullyQualifiedEntityNames | ConversionFlags.SupportExtensionDeclarations));
+			WriteCode(output, options.DecompilerSettings, decompiler.DecompileExtension(extension.MetadataToken), decompiler.TypeSystem);
+		}
+
 		void AddReferenceWarningMessage(MetadataFile module, ITextOutput output)
 		{
 			var loadedAssembly = AssemblyTreeModel.AssemblyList.GetAssemblies().FirstOrDefault(la => la.GetMetadataFileOrNull() == module);

ILSpy/Metadata/CorTables/EventTableTreeNode.cs

@@ -71,7 +71,7 @@ namespace ICSharpCode.ILSpy.Metadata
 
 			IEntity IMemberTreeNode.Member {
 				get {
-					return ((MetadataModule)metadataFile.GetTypeSystemWithCurrentOptionsOrNull(SettingsService, AssemblyTreeModel.CurrentLanguageVersion)?.MainModule)?.GetDefinition(handle);
+					return ((MetadataModule)GetTypeSystemWithCurrentOptionsOrNull(metadataFile)?.MainModule)?.GetDefinition(handle);
 				}
 			}
 

ILSpy/TreeNodes/AssemblyTreeNode.cs

@@ -259,7 +259,7 @@ namespace ICSharpCode.ILSpy.TreeNodes
 
 		void LoadChildrenForExecutableFile(MetadataFile module)
 		{
-			typeSystem = LoadedAssembly.GetTypeSystemOrNull();
+			typeSystem = module.GetTypeSystemWithCurrentOptionsOrNull(SettingsService, AssemblyTreeModel.CurrentLanguageVersion);
 			var assembly = (MetadataModule)typeSystem.MainModule;
 			this.Children.Add(new MetadataTreeNode(module, Resources.Metadata));
 			Decompiler.DebugInfo.IDebugInfoProvider debugInfo = LoadedAssembly.GetDebugInfoOrNull();

ILSpy/TreeNodes/ExtensionTreeNode.cs

@@ -0,0 +1,106 @@
+// 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 ICSharpCode.Decompiler;
+
+using SRM = System.Reflection.Metadata;
+
+namespace ICSharpCode.ILSpy.TreeNodes
+{
+	using System.Collections.Generic;
+	using System.Diagnostics;
+	using System.Linq;
+
+	using ICSharpCode.Decompiler.Output;
+	using ICSharpCode.Decompiler.TypeSystem;
+
+	public sealed class ExtensionTreeNode : ILSpyTreeNode
+	{
+		public ExtensionTreeNode(ITypeDefinition typeDefinition, (IMethod Marker, IReadOnlyList<ITypeParameter> TypeParameters) extensionGroup, AssemblyTreeNode parentAssemblyNode)
+		{
+			this.ParentAssemblyNode = parentAssemblyNode ?? throw new ArgumentNullException(nameof(parentAssemblyNode));
+			this.ContainerTypeDefinition = typeDefinition ?? throw new ArgumentNullException(nameof(typeDefinition));
+			this.MarkerMethod = extensionGroup.Marker ?? throw new ArgumentNullException(nameof(extensionGroup.Marker));
+			this.TypeParameters = extensionGroup.TypeParameters ?? throw new ArgumentNullException(nameof(extensionGroup.TypeParameters));
+			this.LazyLoading = true;
+		}
+
+		public ITypeDefinition ContainerTypeDefinition { get; }
+
+		public IMethod MarkerMethod { get; }
+
+		public IReadOnlyList<ITypeParameter> TypeParameters { get; }
+
+		public AssemblyTreeNode ParentAssemblyNode { get; }
+
+		public override object Icon => Images.GetIcon(TypeIcon.Class, AccessOverlayIcon.Public, false, true);
+
+		public override object Text => this.Language.TypeToString(GetTypeDefinition(), ConversionFlags.SupportExtensionDeclarations);
+
+		public override object NavigationText => this.Language.TypeToString(GetTypeDefinition(), ConversionFlags.UseFullyQualifiedTypeNames | ConversionFlags.UseFullyQualifiedEntityNames | ConversionFlags.SupportExtensionDeclarations);
+
+		private ITypeDefinition GetTypeDefinition()
+		{
+			return ((MetadataModule)ParentAssemblyNode.LoadedAssembly
+				.GetMetadataFileOrNull()
+				?.GetTypeSystemWithCurrentOptionsOrNull(SettingsService, AssemblyTreeModel.CurrentLanguageVersion)
+				?.MainModule)?.GetDefinition((SRM.TypeDefinitionHandle)MarkerMethod.DeclaringTypeDefinition.MetadataToken);
+		}
+
+		protected override void LoadChildren()
+		{
+			var extensionInfo = ContainerTypeDefinition.ExtensionInfo;
+			var subst = new TypeParameterSubstitution(TypeParameters, null);
+
+			foreach (var property in extensionInfo.GetMembersOfGroup(MarkerMethod).OfType<IProperty>().OrderBy(p => p.Name, NaturalStringComparer.Instance))
+			{
+				this.Children.Add(new PropertyTreeNode(property));
+			}
+			foreach (var method in extensionInfo.GetMembersOfGroup(MarkerMethod).OfType<IMethod>().OrderBy(m => m.Name, NaturalStringComparer.Instance))
+			{
+				if (method.MetadataToken.IsNil)
+					continue;
+				this.Children.Add(new MethodTreeNode(method));
+			}
+		}
+
+		public override FilterResult Filter(LanguageSettings settings)
+		{
+			if (LanguageService.Language is not CSharpLanguage)
+				return FilterResult.Hidden;
+
+			var decompilerSettings = SettingsService.DecompilerSettings.Clone();
+			if (!Enum.TryParse(AssemblyTreeModel.CurrentLanguageVersion?.Version, out Decompiler.CSharp.LanguageVersion languageVersion))
+				languageVersion = Decompiler.CSharp.LanguageVersion.Latest;
+			decompilerSettings.SetLanguageVersion(languageVersion);
+
+			if (!decompilerSettings.ExtensionMembers)
+				return FilterResult.Hidden;
+
+			return base.Filter(settings);
+		}
+
+		public override void Decompile(Language language, ITextOutput output, DecompilationOptions options)
+		{
+			Debug.Assert(language is CSharpLanguage);
+			((CSharpLanguage)language).DecompileExtension(GetTypeDefinition(), output, options);
+		}
+	}
+}

ILSpy/TreeNodes/ILSpyTreeNode.cs

@@ -16,6 +16,8 @@
 // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 // DEALINGS IN THE SOFTWARE.
 
+#nullable enable
+
 using System.Collections.Generic;
 using System.Collections.Specialized;
 using System.ComponentModel;
@@ -25,6 +27,7 @@ using System.Reflection.Metadata.Ecma335;
 using System.Windows.Threading;
 
 using ICSharpCode.Decompiler;
+using ICSharpCode.Decompiler.Metadata;
 using ICSharpCode.Decompiler.TypeSystem;
 using ICSharpCode.ILSpy.AssemblyTree;
 using ICSharpCode.ILSpy.Docking;
@@ -48,6 +51,8 @@ namespace ICSharpCode.ILSpy.TreeNodes
 
 		public Language Language => LanguageService.Language;
 
+		protected static ICompilation? GetTypeSystemWithCurrentOptionsOrNull(MetadataFile metadataFile) => metadataFile.GetTypeSystemWithCurrentOptionsOrNull(SettingsService, AssemblyTreeModel.CurrentLanguageVersion);
+
 		protected static AssemblyTreeModel AssemblyTreeModel { get; } = App.ExportProvider.GetExportedValue<AssemblyTreeModel>();
 
 		protected static ICollection<IResourceNodeFactory> ResourceNodeFactories { get; } = App.ExportProvider.GetExportedValues<IResourceNodeFactory>().ToArray();

ILSpy/TreeNodes/MethodTreeNode.cs

@@ -46,9 +46,10 @@ namespace ICSharpCode.ILSpy.TreeNodes
 
 		private IMethod GetMethodDefinition()
 		{
-			return ((MetadataModule)MethodDefinition.ParentModule?.MetadataFile
+			var m = ((MetadataModule)MethodDefinition.ParentModule?.MetadataFile
 				?.GetTypeSystemWithCurrentOptionsOrNull(SettingsService, AssemblyTreeModel.CurrentLanguageVersion)
-				?.MainModule)?.GetDefinition((MethodDefinitionHandle)MethodDefinition.MetadataToken) ?? MethodDefinition;
+				?.MainModule)?.GetDefinition((MethodDefinitionHandle)MethodDefinition.MetadataToken);
+			return m?.Specialize(MethodDefinition.Substitution) ?? MethodDefinition;
 		}
 
 		public static object GetText(IMethod method, Language language, bool includeDeclaringTypeName = false)
@@ -60,10 +61,13 @@ namespace ICSharpCode.ILSpy.TreeNodes
 
 		public static ImageSource GetIcon(IMethod method)
 		{
+			bool isExtensionMethod = method.ResolveExtensionInfo()?.InfoOfExtensionMember((IMethod)method.MemberDefinition).HasValue == true
+				|| method.IsExtensionMethod;
+
 			if (method.IsOperator)
-				return Images.GetIcon(MemberIcon.Operator, Images.GetOverlayIcon(method.Accessibility), false, method.IsExtensionMethod);
+				return Images.GetIcon(MemberIcon.Operator, Images.GetOverlayIcon(method.Accessibility), false, isExtensionMethod);
 
-			if (method.IsExtensionMethod)
+			if (isExtensionMethod)
 				return Images.GetIcon(MemberIcon.Method, Images.GetOverlayIcon(method.Accessibility), false, true);
 
 			if (method.IsConstructor)
@@ -78,13 +82,26 @@ namespace ICSharpCode.ILSpy.TreeNodes
 
 		public override void Decompile(Language language, ITextOutput output, DecompilationOptions options)
 		{
-			language.DecompileMethod(MethodDefinition, output, options);
+			if (Parent is ExtensionTreeNode && language is CSharpLanguage cs)
+				cs.DecompileExtension(MethodDefinition, output, options);
+			else
+				language.DecompileMethod(MethodDefinition, output, options);
 		}
 
 		public override FilterResult Filter(LanguageSettings settings)
 		{
 			if (settings.ShowApiLevel == ApiVisibility.PublicOnly && !IsPublicAPI)
 				return FilterResult.Hidden;
+			// hide implementation methods of extension blocks in the tree view
+			if (Language is CSharpLanguage && MethodDefinition.DeclaringTypeDefinition?.ExtensionInfo is { } extInfo)
+			{
+				var decompilerSettings = SettingsService.DecompilerSettings.Clone();
+				if (!Enum.TryParse(LanguageService.LanguageVersion?.Version, out Decompiler.CSharp.LanguageVersion csharpLanguageVersion))
+					csharpLanguageVersion = Decompiler.CSharp.LanguageVersion.Latest;
+				decompilerSettings.SetLanguageVersion(csharpLanguageVersion);
+				if (decompilerSettings.ExtensionMembers && extInfo.InfoOfImplementationMember((IMethod)MethodDefinition.MemberDefinition).HasValue)
+					return FilterResult.Hidden;
+			}
 			if (settings.SearchTermMatches(MethodDefinition.Name) && (settings.ShowApiLevel == ApiVisibility.All || LanguageService.Language.ShowMember(MethodDefinition)))
 				return FilterResult.Match;
 			else

ILSpy/TreeNodes/PropertyTreeNode.cs

@@ -33,12 +33,9 @@ namespace ICSharpCode.ILSpy.TreeNodes
 	/// </summary>
 	public sealed class PropertyTreeNode : ILSpyTreeNode, IMemberTreeNode
 	{
-		readonly bool isIndexer;
-
 		public PropertyTreeNode(IProperty property)
 		{
 			this.PropertyDefinition = property ?? throw new ArgumentNullException(nameof(property));
-			this.isIndexer = property.IsIndexer;
 
 			if (property.CanGet)
 				this.Children.Add(new MethodTreeNode(property.Getter));
@@ -56,9 +53,10 @@ namespace ICSharpCode.ILSpy.TreeNodes
 
 		private IProperty GetPropertyDefinition()
 		{
-			return ((MetadataModule)PropertyDefinition.ParentModule?.MetadataFile
+			var pd = ((MetadataModule)PropertyDefinition.ParentModule?.MetadataFile
 				?.GetTypeSystemWithCurrentOptionsOrNull(SettingsService, AssemblyTreeModel.CurrentLanguageVersion)
-				?.MainModule)?.GetDefinition((PropertyDefinitionHandle)PropertyDefinition.MetadataToken) ?? PropertyDefinition;
+				?.MainModule)?.GetDefinition((PropertyDefinitionHandle)PropertyDefinition.MetadataToken);
+			return (IProperty)pd?.Specialize(PropertyDefinition.Substitution) ?? PropertyDefinition;
 		}
 
 		public static object GetText(IProperty property, Language language, bool includeDeclaringTypeName = false)
@@ -70,8 +68,10 @@ namespace ICSharpCode.ILSpy.TreeNodes
 
 		public static ImageSource GetIcon(IProperty property)
 		{
+			IMethod accessor = property.Getter ?? property.Setter;
+			bool isExtension = property.ResolveExtensionInfo()?.InfoOfExtensionMember((IMethod)accessor.MemberDefinition) != null;
 			return Images.GetIcon(property.IsIndexer ? MemberIcon.Indexer : MemberIcon.Property,
-				Images.GetOverlayIcon(property.Accessibility), property.IsStatic, false);
+				Images.GetOverlayIcon(property.Accessibility), property.IsStatic, isExtension);
 		}
 
 		public override FilterResult Filter(LanguageSettings settings)
@@ -86,7 +86,10 @@ namespace ICSharpCode.ILSpy.TreeNodes
 
 		public override void Decompile(Language language, ITextOutput output, DecompilationOptions options)
 		{
-			language.DecompileProperty(PropertyDefinition, output, options);
+			if (Parent is ExtensionTreeNode && language is CSharpLanguage cs)
+				cs.DecompileExtension(PropertyDefinition, output, options);
+			else
+				language.DecompileProperty(PropertyDefinition, output, options);
 		}
 
 		public override bool IsPublicAPI {

ILSpy/TreeNodes/TypeTreeNode.cs

@@ -94,6 +94,14 @@ namespace ICSharpCode.ILSpy.TreeNodes
 				this.Children.Add(new BaseTypesTreeNode(ParentAssemblyNode.LoadedAssembly.GetMetadataFileOrNull(), TypeDefinition));
 			if (!TypeDefinition.IsSealed)
 				this.Children.Add(new DerivedTypesTreeNode(ParentAssemblyNode.AssemblyList, TypeDefinition));
+			var extensionInfo = TypeDefinition.ExtensionInfo;
+			if (extensionInfo != null)
+			{
+				foreach (var extensionGroup in TypeDefinition.ExtensionInfo?.ExtensionGroups ?? [])
+				{
+					this.Children.Add(new ExtensionTreeNode(TypeDefinition, extensionGroup, ParentAssemblyNode));
+				}
+			}
 			foreach (var nestedType in TypeDefinition.NestedTypes.OrderBy(t => t.Name, NaturalStringComparer.Instance))
 			{
 				this.Children.Add(new TypeTreeNode(nestedType, ParentAssemblyNode));
@@ -140,7 +148,7 @@ namespace ICSharpCode.ILSpy.TreeNodes
 
 		public static ImageSource GetIcon(ITypeDefinition type)
 		{
-			return Images.GetIcon(GetTypeIcon(type, out bool isStatic), GetOverlayIcon(type), isStatic);
+			return Images.GetIcon(GetTypeIcon(type, out bool isStatic), GetOverlayIcon(type), isStatic, false);
 		}
 
 		internal static TypeIcon GetTypeIcon(IType type, out bool isStatic)
@@ -163,7 +171,7 @@ namespace ICSharpCode.ILSpy.TreeNodes
 			}
 		}
 
-		static AccessOverlayIcon GetOverlayIcon(ITypeDefinition type)
+		internal static AccessOverlayIcon GetOverlayIcon(ITypeDefinition type)
 		{
 			switch (type.Accessibility)
 			{