add "Referenced Types" under References

ICSharpCode.Decompiler/ICSharpCode.Decompiler.csproj

@@ -362,6 +362,7 @@
     <Compile Include="IL\Transforms\TransformDisplayClassUsage.cs" />
     <Compile Include="IL\Transforms\UserDefinedLogicTransform.cs" />
     <Compile Include="Metadata\AssemblyReferences.cs" />
+    <Compile Include="Metadata\TypeReferenceMetadata.cs" />
     <Compile Include="Metadata\CodeMappingInfo.cs" />
     <Compile Include="Metadata\EnumUnderlyingTypeResolveException.cs" />
     <Compile Include="Metadata\MetadataTokenHelpers.cs" />

ICSharpCode.Decompiler/Metadata/AssemblyReferences.cs

@@ -19,6 +19,7 @@
 #nullable enable
 
 using System;
+using System.Collections.Immutable;
 using System.Diagnostics.CodeAnalysis;
 using System.Linq;
 using System.Reflection;
@@ -275,6 +276,24 @@ namespace ICSharpCode.Decompiler.Metadata
 			return bytes;
 		}
 
+		ImmutableArray<TypeReferenceMetadata> typeReferences;
+		public ImmutableArray<TypeReferenceMetadata> TypeReferences {
+			get {
+				var value = typeReferences;
+				if (value.IsDefault)
+				{
+					value = Metadata.TypeReferences
+						.Select(r => new TypeReferenceMetadata(Metadata, r))
+						.Where(r => r.ResolutionScope == Handle)
+						.OrderBy(r => r.Namespace)
+						.ThenBy(r => r.Name)
+						.ToImmutableArray();
+					typeReferences = value;
+				}
+				return value;
+			}
+		}
+
 		public AssemblyReference(MetadataReader metadata, AssemblyReferenceHandle handle)
 		{
 			if (metadata == null)

ICSharpCode.Decompiler/Metadata/TypeReferenceMetadata.cs

@@ -0,0 +1,95 @@
+// Copyright (c) 2023 James May
+// 
+// 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.
+
+#nullable enable
+
+using System;
+using System.Collections.Immutable;
+using System.Linq;
+using System.Reflection.Metadata;
+
+namespace ICSharpCode.Decompiler.Metadata
+{
+#if !VSADDIN
+	public sealed class TypeReferenceMetadata
+	{
+		readonly TypeReference entry;
+
+		public MetadataReader Metadata { get; }
+		public TypeReferenceHandle Handle { get; }
+
+		string? name;
+		public string Name {
+			get {
+				try
+				{
+					return name ??= Metadata.GetString(entry.Name);
+				}
+				catch (BadImageFormatException)
+				{
+					return name = $"TR:{Handle}";
+				}
+			}
+		}
+
+		string? @namespace;
+		public string Namespace {
+			get {
+				try
+				{
+					return @namespace ??= Metadata.GetString(entry.Namespace);
+				}
+				catch (BadImageFormatException)
+				{
+					return @namespace = $"namespace(TR:{Handle})";
+				}
+			}
+		}
+
+		public EntityHandle ResolutionScope => entry.ResolutionScope;
+
+		ImmutableArray<TypeReferenceMetadata> typeReferences;
+		public ImmutableArray<TypeReferenceMetadata> TypeReferences {
+			get {
+				var value = typeReferences;
+				if (value.IsDefault)
+				{
+					value = Metadata.TypeReferences
+						.Select(r => new TypeReferenceMetadata(Metadata, r))
+						.Where(r => r.ResolutionScope == Handle)
+						.OrderBy(r => r.Name)
+						.ToImmutableArray();
+					typeReferences = value;
+				}
+				return value;
+			}
+		}
+
+		public TypeReferenceMetadata(MetadataReader metadata, TypeReferenceHandle handle)
+		{
+			Metadata = metadata ?? throw new ArgumentNullException(nameof(metadata));
+			if (handle.IsNil)
+				throw new ArgumentNullException(nameof(handle));
+			Handle = handle;
+			entry = metadata.GetTypeReference(handle);
+		}
+
+		public override string ToString() => $"{Namespace}::{Name}";
+	}
+#endif
+}

ILSpy/TreeNodes/AssemblyReferenceReferencedTypesTreeNode.cs

@@ -0,0 +1,60 @@
+// Copyright (c) 2023 James May
+// 
+// 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 ICSharpCode.Decompiler.Metadata;
+
+namespace ICSharpCode.ILSpy.TreeNodes
+{
+	/// <summary>
+	/// Referenced Types node in assembly reference list
+	/// </summary>
+	public sealed class AssemblyReferenceReferencedTypesTreeNode : ILSpyTreeNode
+	{
+		private readonly PEFile module;
+		private readonly AssemblyReference r;
+
+		public AssemblyReferenceReferencedTypesTreeNode(PEFile module, AssemblyReference r)
+		{
+			this.module = module ?? throw new ArgumentNullException(nameof(module));
+			this.r = r ?? throw new ArgumentNullException(nameof(r));
+
+			this.LazyLoading = true;
+		}
+
+		public override object Text => $"Referenced Types ({r.TypeReferences.Length})";
+		public override object Icon => Images.Class;
+
+		protected override void LoadChildren()
+		{
+			foreach (var typeRef in r.TypeReferences)
+				this.Children.Add(new TypeReferenceTreeNode(module, typeRef));
+		}
+
+		public override bool ShowExpander => !r.TypeReferences.IsEmpty;
+
+		public override void Decompile(Language language, ITextOutput output, DecompilationOptions options)
+		{
+			EnsureLazyChildren();
+			foreach (ILSpyTreeNode child in Children)
+				child.Decompile(language, output, options);
+		}
+	}
+}

ILSpy/TreeNodes/AssemblyReferenceTreeNode.cs

@@ -29,17 +29,19 @@ namespace ICSharpCode.ILSpy.TreeNodes
 	/// </summary>
 	public sealed class AssemblyReferenceTreeNode : ILSpyTreeNode
 	{
+		readonly PEFile module;
 		readonly AssemblyReference r;
 		readonly AssemblyTreeNode parentAssembly;
 
-		public AssemblyReferenceTreeNode(AssemblyReference r, AssemblyTreeNode parentAssembly)
+		public AssemblyReferenceTreeNode(PEFile module, AssemblyReference r, AssemblyTreeNode parentAssembly)
 		{
+			this.module = module ?? throw new ArgumentNullException(nameof(module));
 			this.r = r ?? throw new ArgumentNullException(nameof(r));
 			this.parentAssembly = parentAssembly ?? throw new ArgumentNullException(nameof(parentAssembly));
 			this.LazyLoading = true;
 		}
 
-		public IAssemblyReference AssemblyNameReference => r;
+		public AssemblyReference AssemblyReference => r;
 
 		public override object Text {
 			get { return Language.EscapeName(r.Name) + GetSuffixString(r.Handle); }
@@ -75,12 +77,14 @@ namespace ICSharpCode.ILSpy.TreeNodes
 
 		protected override void LoadChildren()
 		{
+			this.Children.Add(new AssemblyReferenceReferencedTypesTreeNode(module, r));
+
 			var resolver = parentAssembly.LoadedAssembly.GetAssemblyResolver(MainWindow.Instance.CurrentDecompilerSettings.AutoLoadAssemblyReferences);
-			var module = resolver.Resolve(r);
-			if (module != null)
+			var referencedModule = resolver.Resolve(r);
+			if (referencedModule != null)
 			{
-				foreach (var childRef in module.AssemblyReferences)
-					this.Children.Add(new AssemblyReferenceTreeNode(childRef, parentAssembly));
+				foreach (var childRef in referencedModule.AssemblyReferences)
+					this.Children.Add(new AssemblyReferenceTreeNode(referencedModule, childRef, parentAssembly));
 			}
 		}
 

ILSpy/TreeNodes/ReferenceFolderTreeNode.cs

@@ -49,7 +49,7 @@ namespace ICSharpCode.ILSpy.TreeNodes
 		{
 			var metadata = module.Metadata;
 			foreach (var r in module.AssemblyReferences.OrderBy(r => r.Name))
-				this.Children.Add(new AssemblyReferenceTreeNode(r, parentAssembly));
+				this.Children.Add(new AssemblyReferenceTreeNode(module, r, parentAssembly));
 			foreach (var r in metadata.GetModuleReferences().OrderBy(r => metadata.GetString(metadata.GetModuleReference(r).Name)))
 				this.Children.Add(new ModuleReferenceTreeNode(parentAssembly, r, metadata));
 		}

ILSpy/TreeNodes/TypeReferenceTreeNode.cs

@@ -0,0 +1,59 @@
+// Copyright (c) 2023 James May
+// 
+// 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 ICSharpCode.Decompiler.Metadata;
+
+namespace ICSharpCode.ILSpy.TreeNodes
+{
+	/// <summary>
+	/// referenced type within assembly reference list.
+	/// </summary>
+	public sealed class TypeReferenceTreeNode : ILSpyTreeNode
+	{
+		readonly PEFile module;
+		private readonly TypeReferenceMetadata r;
+
+		public TypeReferenceTreeNode(PEFile module, TypeReferenceMetadata r)
+		{
+			this.module = module ?? throw new ArgumentNullException(nameof(module));
+			this.r = r ?? throw new ArgumentNullException(nameof(r));
+
+			this.LazyLoading = true;
+		}
+
+		public override object Text
+			=> Language.GetEntityName(module, r.Handle, fullName: true, omitGenerics: false) + GetSuffixString(r.Handle);
+
+		public override object Icon => Images.Class;
+
+		public override void Decompile(Language language, ITextOutput output, DecompilationOptions options)
+		{
+			language.WriteCommentLine(output, $"{Language.GetEntityName(module, r.Handle, fullName: true, omitGenerics: false)}");
+			EnsureLazyChildren();
+			foreach (ILSpyTreeNode child in Children)
+			{
+				output.Indent();
+				child.Decompile(language, output, options);
+				output.Unindent();
+			}
+		}
+	}
+}