Fix DerivedTypesTreeNode and BaseTypesTreeNode

ILSpy/TreeNodes/BaseTypesEntryNode.cs

@@ -34,7 +34,6 @@ namespace ICSharpCode.ILSpy.TreeNodes
 		readonly IType type;
 		readonly bool isInterface;
 		bool showExpander;
-		object text;
 
 		public BaseTypesEntryNode(PEFile module, EntityHandle handle, IType type, bool isInterface)
 		{
@@ -57,19 +56,17 @@ namespace ICSharpCode.ILSpy.TreeNodes
 				var other = t.ParentAssembly.PEFile.GetTypeSystemOrNull();
 				Debug.Assert(other != null);
 				t = other.FindType(t.FullTypeName).GetDefinition();
-				text = this.Language.TypeToString(Language.MakeParameterizedType(t), includeNamespace: true) + handle.ToSuffixString();
 			} else {
 				showExpander = mayRetry;
-				text = this.Language.TypeToString(type, includeNamespace: true) + handle.ToSuffixString();
 			}
 			RaisePropertyChanged(nameof(Text));
 			RaisePropertyChanged(nameof(ShowExpander));
 			return t;
 		}
 
-		public override bool ShowExpander => showExpander;
+		public override bool ShowExpander => showExpander && base.ShowExpander;
 
-		public override object Text => text;
+		public override object Text => this.Language.TypeToString(type, includeNamespace: true) + handle.ToSuffixString();
 
 		public override object Icon => isInterface ? Images.Interface : Images.Class;
 

ILSpy/TreeNodes/DerivedTypesEntryNode.cs

@@ -17,55 +17,42 @@
 // DEALINGS IN THE SOFTWARE.
 
 using System.Collections.Generic;
-using System.Reflection;
+using System.Linq;
-using System.Reflection.PortableExecutable;
 using System.Threading;
 using ICSharpCode.Decompiler;
-using ICSharpCode.Decompiler.Metadata;
 using ICSharpCode.Decompiler.TypeSystem;
-using SRM = System.Reflection.Metadata;
 
 namespace ICSharpCode.ILSpy.TreeNodes
 {
 	class DerivedTypesEntryNode : ILSpyTreeNode, IMemberTreeNode
 	{
-		private readonly ITypeDefinition type;
+		readonly AssemblyList list;
-	/*	private readonly PEFile[] assemblies;
+		readonly ITypeDefinition type;
-		private readonly ThreadingSupport threading;
+		readonly ThreadingSupport threading;
-		private readonly SRM.TypeDefinition td;
 
-		public DerivedTypesEntryNode(ITypeDefinition type, PEFile[] assemblies)
+		public DerivedTypesEntryNode(AssemblyList list, ITypeDefinition type)
 		{
+			this.list = list;
 			this.type = type;
-			this.td = type.Module.Metadata.GetTypeDefinition(type.Handle);
-			this.assemblies = assemblies;
 			this.LazyLoading = true;
 			threading = new ThreadingSupport();
 		}
 
-		public override bool ShowExpander
+		public override bool ShowExpander => !type.IsSealed && base.ShowExpander;
-		{
-			get { return !type.Module.Metadata.GetTypeDefinition(type.Handle).HasFlag(TypeAttributes.Sealed) && base.ShowExpander; }
-		}
 
 		public override object Text
 		{
-			get { return type.Handle.GetFullTypeName(type.Module.Metadata) + type.Handle.ToSuffixString(); }
+			get { return type.FullName + type.MetadataToken.ToSuffixString(); }
 		}
 
-		public override object Icon
+		public override object Icon => TypeTreeNode.GetIcon(type);
-		{
-			get { return TypeTreeNode.GetIcon(type); }
-		}
 
 		public override FilterResult Filter(FilterSettings settings)
 		{
 			if (!settings.ShowInternalApi && !IsPublicAPI)
 				return FilterResult.Hidden;
-			var metadata = type.Module.Metadata;
+			if (settings.SearchTermMatches(type.Name)) {
-			var typeDefinition = metadata.GetTypeDefinition(type.Handle);
+				if (type.DeclaringType != null && !settings.Language.ShowMember(type))
-			if (settings.SearchTermMatches(metadata.GetString(typeDefinition.Name))) {
-				if (!typeDefinition.GetDeclaringType().IsNil && !settings.Language.ShowMember(type))
 					return FilterResult.Hidden;
 				else
 					return FilterResult.Match;
@@ -75,11 +62,10 @@ namespace ICSharpCode.ILSpy.TreeNodes
 		
 		public override bool IsPublicAPI {
 			get {
-				switch (td.Attributes & TypeAttributes.VisibilityMask) {
+				switch (type.Accessibility) {
-					case TypeAttributes.Public:
+					case Accessibility.Public:
-					case TypeAttributes.NestedPublic:
+					case Accessibility.Internal:
-					case TypeAttributes.NestedFamily:
+					case Accessibility.ProtectedOrInternal:
-					case TypeAttributes.NestedFamORAssem:
 						return true;
 					default:
 						return false;
@@ -95,13 +81,14 @@ namespace ICSharpCode.ILSpy.TreeNodes
 		IEnumerable<ILSpyTreeNode> FetchChildren(CancellationToken ct)
 		{
 			// FetchChildren() runs on the main thread; but the enumerator will be consumed on a background thread
-			return DerivedTypesTreeNode.FindDerivedTypes(type, assemblies, ct);
+			var assemblies = list.GetAssemblies().Select(node => node.GetPEFileOrNull()).Where(asm => asm != null).ToArray();
+			return DerivedTypesTreeNode.FindDerivedTypes(list, type, assemblies, ct);
 		}
 
 		public override void ActivateItem(System.Windows.RoutedEventArgs e)
 		{
 			e.Handled = BaseTypesEntryNode.ActivateItem(this, type);
-		}*/
+		}
 
 		public override void Decompile(Language language, ITextOutput output, DecompilationOptions options)
 		{

ILSpy/TreeNodes/DerivedTypesTreeNode.cs

@@ -22,7 +22,6 @@ using System.Threading;
 using ICSharpCode.Decompiler;
 using ICSharpCode.Decompiler.Metadata;
 using ICSharpCode.Decompiler.TypeSystem;
-using ICSharpCode.Decompiler.Util;
 
 using SRM = System.Reflection.Metadata;
 
@@ -58,35 +57,39 @@ namespace ICSharpCode.ILSpy.TreeNodes
 		{
 			// FetchChildren() runs on the main thread; but the enumerator will be consumed on a background thread
 			var assemblies = list.GetAssemblies().Select(node => node.GetPEFileOrNull()).Where(asm => asm != null).ToArray();
-			return FindDerivedTypes(type, assemblies, cancellationToken);
+			return FindDerivedTypes(list, type, assemblies, cancellationToken);
 		}
 
-		internal static IEnumerable<DerivedTypesEntryNode> FindDerivedTypes(ITypeDefinition type, PEFile[] assemblies, CancellationToken cancellationToken)
+		internal static IEnumerable<DerivedTypesEntryNode> FindDerivedTypes(AssemblyList list, ITypeDefinition type,
+			PEFile[] assemblies, CancellationToken cancellationToken)
 		{
-			/*foreach (var module in assemblies) {
+			var definitionMetadata = type.ParentAssembly.PEFile.Metadata;
-				var typeSystem = new DecompilerTypeSystem(module, module.GetAssemblyResolver());
+			var metadataToken = (SRM.TypeDefinitionHandle)type.MetadataToken;
-				foreach (var td in typeSystem.MainAssembly.TypeDefinitions) {
+			foreach (var module in assemblies) {
+				var metadata = module.Metadata;
+				var assembly = (MetadataAssembly)module.GetTypeSystemOrNull().MainAssembly;
+				foreach (var h in metadata.TypeDefinitions) {
 					cancellationToken.ThrowIfCancellationRequested();
-					var td = new TypeDefinition(module, h);
+					var td = metadata.GetTypeDefinition(h);
-					var typeDefinition = metadata.GetTypeDefinition(h);
+					foreach (var iface in td.GetInterfaceImplementations()) {
-					foreach (var iface in typeDefinition.GetInterfaceImplementations()) {
 						var ifaceImpl = metadata.GetInterfaceImplementation(iface);
-						if (IsSameType(metadata, ifaceImpl.Interface, type))
+						if (IsSameType(metadata, ifaceImpl.Interface, definitionMetadata, metadataToken))
-							yield return new DerivedTypesEntryNode(td, assemblies);
+							yield return new DerivedTypesEntryNode(list, assembly.GetDefinition(h));
 					}
-					if (!typeDefinition.BaseType.IsNil && IsSameType(metadata, typeDefinition.BaseType, type)) {
+					if (!td.BaseType.IsNil && IsSameType(metadata, td.BaseType, definitionMetadata, metadataToken)) {
-						yield return new DerivedTypesEntryNode(td, assemblies);
+						yield return new DerivedTypesEntryNode(list, assembly.GetDefinition(h));
 					}
 				}
-			}*/
+			}
 			yield break;
 		}
-		/*
+
-		static bool IsSameType(SRM.MetadataReader referenceMetadata, SRM.EntityHandle typeRef, ITypeDefinition type)
+		static bool IsSameType(SRM.MetadataReader referenceMetadata, SRM.EntityHandle typeRef,
+			                   SRM.MetadataReader definitionMetadata, SRM.TypeDefinitionHandle typeDef)
 		{
 			// FullName contains only namespace, name and type parameter count, therefore this should suffice.
-			return typeRef.GetFullTypeName(referenceMetadata) == type.Handle.GetFullTypeName(type.Module.Metadata);
+			return typeRef.GetFullTypeName(referenceMetadata) == typeDef.GetFullTypeName(definitionMetadata);
-		}*/
+		}
 
 		public override void Decompile(Language language, ITextOutput output, DecompilationOptions options)
 		{