Use the resolve methods in MetadataModule, and remove the wrappers in DecompilerTypeSystem.

ICSharpCode.Decompiler.Tests/Helpers/Tester.cs

@@ -400,7 +400,7 @@ namespace ICSharpCode.Decompiler.Tests.Helpers
 				var resolver = new UniversalAssemblyResolver(assemblyFileName, false,
 					module.Reader.DetectTargetFrameworkId(), PEStreamOptions.PrefetchMetadata);
 				var typeSystem = new DecompilerTypeSystem(module, resolver);
-				CSharpDecompiler decompiler = new CSharpDecompiler(typeSystem, resolver, settings ?? new DecompilerSettings());
+				CSharpDecompiler decompiler = new CSharpDecompiler(typeSystem, settings ?? new DecompilerSettings());
 				decompiler.AstTransforms.Insert(0, new RemoveEmbeddedAtttributes());
 				decompiler.AstTransforms.Insert(0, new RemoveCompilerAttribute());
 				decompiler.AstTransforms.Add(new EscapeInvalidIdentifiers());

ICSharpCode.Decompiler/CSharp/CSharpDecompiler.cs

@@ -55,7 +55,9 @@ namespace ICSharpCode.Decompiler.CSharp
 	/// </remarks>
 	public class CSharpDecompiler
 	{
-		readonly DecompilerTypeSystem typeSystem;
+		readonly IDecompilerTypeSystem typeSystem;
+		readonly MetadataModule module;
+		readonly MetadataReader metadata;
 		readonly DecompilerSettings settings;
 		SyntaxTree syntaxTree;
 
@@ -183,8 +185,6 @@ namespace ICSharpCode.Decompiler.CSharp
 
 		public IDecompilerTypeSystem TypeSystem => typeSystem;
 
-		public IAssemblyResolver AssemblyResolver { get; }
-
 		/// <summary>
 		/// Gets or sets the optional provider for debug info.
 		/// </summary>
@@ -215,15 +215,16 @@ namespace ICSharpCode.Decompiler.CSharp
 		}
 
 		public CSharpDecompiler(PEFile module, IAssemblyResolver assemblyResolver, DecompilerSettings settings)
-			: this(new DecompilerTypeSystem(module, assemblyResolver, settings), assemblyResolver, settings)
+			: this(new DecompilerTypeSystem(module, assemblyResolver, settings), settings)
 		{
 		}
 
-		public CSharpDecompiler(DecompilerTypeSystem typeSystem, IAssemblyResolver assemblyResolver, DecompilerSettings settings)
+		public CSharpDecompiler(DecompilerTypeSystem typeSystem, DecompilerSettings settings)
 		{
 			this.typeSystem = typeSystem ?? throw new ArgumentNullException(nameof(typeSystem));
-			this.AssemblyResolver = assemblyResolver ?? throw new ArgumentNullException(nameof(assemblyResolver));
 			this.settings = settings;
+			this.module = typeSystem.MainModule;
+			this.metadata = module.PEFile.Metadata;
 		}
 
 		#region MemberIsHidden
@@ -348,7 +349,7 @@ namespace ICSharpCode.Decompiler.CSharp
 
 		IDocumentationProvider CreateDefaultDocumentationProvider()
 		{
-			return XmlDocLoader.LoadDocumentation(typeSystem.ModuleDefinition);
+			return XmlDocLoader.LoadDocumentation(module.PEFile);
 		}
 
 		void RunTransforms(AstNode rootNode, DecompileRun decompileRun, ITypeResolveContext decompilationContext)
@@ -380,7 +381,7 @@ namespace ICSharpCode.Decompiler.CSharp
 				CancellationToken = CancellationToken
 			};
 			syntaxTree = new SyntaxTree();
-			RequiredNamespaceCollector.CollectAttributeNamespaces(typeSystem, decompileRun.Namespaces);
+			RequiredNamespaceCollector.CollectAttributeNamespaces(module, decompileRun.Namespaces);
 			DoDecompileModuleAndAssemblyAttributes(decompileRun, decompilationContext, syntaxTree);
 			RunTransforms(syntaxTree, decompileRun, decompilationContext);
 			return syntaxTree;
@@ -414,11 +415,11 @@ namespace ICSharpCode.Decompiler.CSharp
 		{
 			string currentNamespace = null;
 			AstNode groupNode = null;
-			foreach (var cecilType in types) {
-				var typeDef = typeSystem.ResolveAsType(cecilType).GetDefinition();
+			foreach (var typeDefHandle in types) {
+				var typeDef = module.GetDefinition(typeDefHandle);
 				if (typeDef.Name == "<Module>" && typeDef.Members.Count == 0)
 					continue;
-				if (MemberIsHidden(typeSystem.ModuleDefinition, cecilType, settings))
+				if (MemberIsHidden(module.PEFile, typeDefHandle, settings))
 					continue;
 				if(string.IsNullOrEmpty(typeDef.Namespace)) {
 					groupNode = syntaxTree;
@@ -445,8 +446,7 @@ namespace ICSharpCode.Decompiler.CSharp
 				CancellationToken = CancellationToken
 			};
 			syntaxTree = new SyntaxTree();
-			MetadataReader metadata = typeSystem.ModuleDefinition.Metadata;
-			RequiredNamespaceCollector.CollectNamespaces(typeSystem, decompileRun.Namespaces);
+			RequiredNamespaceCollector.CollectNamespaces(module, decompileRun.Namespaces);
 			DoDecompileModuleAndAssemblyAttributes(decompileRun, decompilationContext, syntaxTree);
 			DoDecompileTypes(metadata.GetTopLevelTypeDefinitions(), decompileRun, decompilationContext, syntaxTree);
 			RunTransforms(syntaxTree, decompileRun, decompilationContext);
@@ -459,7 +459,7 @@ namespace ICSharpCode.Decompiler.CSharp
 				DocumentationProvider = DocumentationProvider ?? CreateDefaultDocumentationProvider(),
 				CancellationToken = CancellationToken
 			};
-			RequiredNamespaceCollector.CollectNamespaces(function.Method, typeSystem, decompileRun.Namespaces);
+			RequiredNamespaceCollector.CollectNamespaces(function.Method, module, decompileRun.Namespaces);
 			return new ILTransformContext(function, typeSystem, DebugInfoProvider, settings) {
 				CancellationToken = CancellationToken,
 				DecompileRun = decompileRun
@@ -576,7 +576,7 @@ namespace ICSharpCode.Decompiler.CSharp
 			foreach (var type in types) {
 				if (type.IsNil)
 					throw new ArgumentException("types contains null element");
-				RequiredNamespaceCollector.CollectNamespaces(type, typeSystem, decompileRun.Namespaces);
+				RequiredNamespaceCollector.CollectNamespaces(type, module, decompileRun.Namespaces);
 			}
 
 			DoDecompileTypes(types, decompileRun, decompilationContext, syntaxTree);
@@ -612,7 +612,7 @@ namespace ICSharpCode.Decompiler.CSharp
 				CancellationToken = CancellationToken
 			};
 			syntaxTree = new SyntaxTree();
-			RequiredNamespaceCollector.CollectNamespaces(type.MetadataToken, typeSystem, decompileRun.Namespaces);
+			RequiredNamespaceCollector.CollectNamespaces(type.MetadataToken, module, decompileRun.Namespaces);
 			DoDecompileTypes(new[] { (TypeDefinitionHandle)type.MetadataToken }, decompileRun, decompilationContext, syntaxTree);
 			RunTransforms(syntaxTree, decompileRun, decompilationContext);
 			return syntaxTree;
@@ -653,43 +653,33 @@ namespace ICSharpCode.Decompiler.CSharp
 			foreach (var entity in definitions) {
 				if (entity.IsNil)
 					throw new ArgumentException("definitions contains null element");
-				RequiredNamespaceCollector.CollectNamespaces(entity, typeSystem, decompileRun.Namespaces);
+				RequiredNamespaceCollector.CollectNamespaces(entity, module, decompileRun.Namespaces);
 			}
 
 			foreach (var entity in definitions) {
 				switch (entity.Kind) {
 					case HandleKind.TypeDefinition:
-						ITypeDefinition typeDef = typeSystem.ResolveAsType(entity).GetDefinition();
-						if (typeDef == null)
-							throw new InvalidOperationException("Could not find type definition in NR type system");
+						ITypeDefinition typeDef = module.GetDefinition((TypeDefinitionHandle)entity);
 						syntaxTree.Members.Add(DoDecompile(typeDef, decompileRun, new SimpleTypeResolveContext(typeDef)));
 						parentTypeDef = typeDef.DeclaringTypeDefinition;
 						break;
 					case HandleKind.MethodDefinition:
-						IMethod method = typeSystem.ResolveAsMethod(entity);
-						if (method == null)
-							throw new InvalidOperationException("Could not find method definition in NR type system");
+						IMethod method = module.GetDefinition((MethodDefinitionHandle)entity);
 						syntaxTree.Members.Add(DoDecompile(method, decompileRun, new SimpleTypeResolveContext(method)));
 						parentTypeDef = method.DeclaringTypeDefinition;
 						break;
 					case HandleKind.FieldDefinition:
-						IField field = typeSystem.ResolveAsField(entity);
-						if (field == null)
-							throw new InvalidOperationException("Could not find field definition in NR type system");
+						IField field = module.GetDefinition((FieldDefinitionHandle)entity);
 						syntaxTree.Members.Add(DoDecompile(field, decompileRun, new SimpleTypeResolveContext(field)));
 						parentTypeDef = field.DeclaringTypeDefinition;
 						break;
 					case HandleKind.PropertyDefinition:
-						IProperty property = typeSystem.ResolveAsProperty(entity);
-						if (property == null)
-							throw new InvalidOperationException("Could not find property definition in NR type system");
+						IProperty property = module.GetDefinition((PropertyDefinitionHandle)entity);
 						syntaxTree.Members.Add(DoDecompile(property, decompileRun, new SimpleTypeResolveContext(property)));
 						parentTypeDef = property.DeclaringTypeDefinition;
 						break;
 					case HandleKind.EventDefinition:
-						IEvent ev = typeSystem.ResolveAsEvent(entity);
-						if (ev == null)
-							throw new InvalidOperationException("Could not find event definition in NR type system");
+						IEvent ev = module.GetDefinition((EventDefinitionHandle)entity);
 						syntaxTree.Members.Add(DoDecompile(ev, decompileRun, new SimpleTypeResolveContext(ev)));
 						parentTypeDef = ev.DeclaringTypeDefinition;
 						break;
@@ -717,16 +707,18 @@ namespace ICSharpCode.Decompiler.CSharp
 			return SyntaxTreeToString(Decompile(definitions));
 		}
 
-		IEnumerable<EntityDeclaration> AddInterfaceImplHelpers(EntityDeclaration memberDecl, MethodDefinitionHandle methodHandle,
-		                                                       TypeSystemAstBuilder astBuilder)
+		IEnumerable<EntityDeclaration> AddInterfaceImplHelpers(
+			EntityDeclaration memberDecl, IMethod method,
+			TypeSystemAstBuilder astBuilder)
 		{
 			if (!memberDecl.GetChildByRole(EntityDeclaration.PrivateImplementationTypeRole).IsNull) {
 				yield break; // cannot create forwarder for existing explicit interface impl
 			}
-			MetadataReader metadata = typeSystem.ModuleDefinition.Metadata;
+			var genericContext = new Decompiler.TypeSystem.GenericContext(method);
+			var methodHandle = (MethodDefinitionHandle)method.MetadataToken;
 			foreach (var h in methodHandle.GetMethodImplementations(metadata)) {
 				var mi = metadata.GetMethodImplementation(h);
-				IMethod m = typeSystem.ResolveAsMethod(mi.MethodDeclaration);
+				IMethod m = module.ResolveMethod(mi.MethodDeclaration, genericContext);
 				if (m == null || m.DeclaringType.Kind != TypeKind.Interface)
 					continue;
 				var methodDecl = new MethodDeclaration();
@@ -827,35 +819,35 @@ namespace ICSharpCode.Decompiler.CSharp
 				return entityDecl;
 			}
 			foreach (var type in typeDef.NestedTypes) {
-				if (!type.MetadataToken.IsNil && !MemberIsHidden(typeSystem.ModuleDefinition, type.MetadataToken, settings)) {
+				if (!type.MetadataToken.IsNil && !MemberIsHidden(module.PEFile, type.MetadataToken, settings)) {
 					var nestedType = DoDecompile(type, decompileRun, decompilationContext.WithCurrentTypeDefinition(type));
 					SetNewModifier(nestedType);
 					typeDecl.Members.Add(nestedType);
 				}
 			}
 			foreach (var field in typeDef.Fields) {
-				if (!field.MetadataToken.IsNil && !MemberIsHidden(typeSystem.ModuleDefinition, field.MetadataToken, settings)) {
+				if (!field.MetadataToken.IsNil && !MemberIsHidden(module.PEFile, field.MetadataToken, settings)) {
 					var memberDecl = DoDecompile(field, decompileRun, decompilationContext.WithCurrentMember(field));
 					typeDecl.Members.Add(memberDecl);
 				}
 			}
 			foreach (var property in typeDef.Properties) {
-				if (!property.MetadataToken.IsNil && !MemberIsHidden(typeSystem.ModuleDefinition, property.MetadataToken, settings)) {
+				if (!property.MetadataToken.IsNil && !MemberIsHidden(module.PEFile, property.MetadataToken, settings)) {
 					var propDecl = DoDecompile(property, decompileRun, decompilationContext.WithCurrentMember(property));
 					typeDecl.Members.Add(propDecl);
 				}
 			}
 			foreach (var @event in typeDef.Events) {
-				if (!@event.MetadataToken.IsNil && !MemberIsHidden(typeSystem.ModuleDefinition, @event.MetadataToken, settings)) {
+				if (!@event.MetadataToken.IsNil && !MemberIsHidden(module.PEFile, @event.MetadataToken, settings)) {
 					var eventDecl = DoDecompile(@event, decompileRun, decompilationContext.WithCurrentMember(@event));
 					typeDecl.Members.Add(eventDecl);
 				}
 			}
 			foreach (var method in typeDef.Methods) {
-				if (!method.MetadataToken.IsNil && !MemberIsHidden(typeSystem.ModuleDefinition, method.MetadataToken, settings)) {
+				if (!method.MetadataToken.IsNil && !MemberIsHidden(module.PEFile, method.MetadataToken, settings)) {
 					var memberDecl = DoDecompile(method, decompileRun, decompilationContext.WithCurrentMember(method));
 					typeDecl.Members.Add(memberDecl);
-					typeDecl.Members.AddRange(AddInterfaceImplHelpers(memberDecl, (MethodDefinitionHandle)method.MetadataToken, typeSystemAstBuilder));
+					typeDecl.Members.AddRange(AddInterfaceImplHelpers(memberDecl, method, typeSystemAstBuilder));
 				}
 			}
 			if (typeDecl.Members.OfType<IndexerDeclaration>().Any(idx => idx.PrivateImplementationType.IsNull)) {
@@ -879,7 +871,7 @@ namespace ICSharpCode.Decompiler.CSharp
 				}
 			}
 			if (typeDecl.ClassType == ClassType.Enum) {
-				switch (DetectBestEnumValueDisplayMode(typeDef, typeSystem.ModuleDefinition)) {
+				switch (DetectBestEnumValueDisplayMode(typeDef, module.PEFile)) {
 					case EnumValueDisplayMode.FirstOnly:
 						foreach (var enumMember in typeDecl.Members.OfType<EnumMemberDeclaration>().Skip(1)) {
 							enumMember.Initializer = null;
@@ -981,7 +973,7 @@ namespace ICSharpCode.Decompiler.CSharp
 				methodDecl.Name = method.Name.Substring(lastDot + 1);
 			}
 			FixParameterNames(methodDecl);
-			var methodDefinition = typeSystem.GetMetadata().GetMethodDefinition((MethodDefinitionHandle)method.MetadataToken);
+			var methodDefinition = metadata.GetMethodDefinition((MethodDefinitionHandle)method.MetadataToken);
 			if (methodDefinition.HasBody()) {
 				DecompileBody(method, methodDecl, decompileRun, decompilationContext);
 			} else if (!method.IsAbstract && method.DeclaringType.Kind != TypeKind.Interface) {
@@ -1005,8 +997,8 @@ namespace ICSharpCode.Decompiler.CSharp
 					UseDebugSymbols = settings.UseDebugSymbols,
 					DebugInfo = DebugInfoProvider
 				};
-				var methodDef = typeSystem.ModuleDefinition.Metadata.GetMethodDefinition((MethodDefinitionHandle)method.MetadataToken);
-				var methodBody = typeSystem.ModuleDefinition.Reader.GetMethodBody(methodDef.RelativeVirtualAddress);
+				var methodDef = metadata.GetMethodDefinition((MethodDefinitionHandle)method.MetadataToken);
+				var methodBody = module.PEFile.Reader.GetMethodBody(methodDef.RelativeVirtualAddress);
 				var function = ilReader.ReadIL((MethodDefinitionHandle)method.MetadataToken, methodBody, cancellationToken: CancellationToken);
 				function.CheckInvariant(ILPhase.Normal);
 
@@ -1074,7 +1066,7 @@ namespace ICSharpCode.Decompiler.CSharp
 					RemoveAttribute(entityDecl, KnownAttribute.DebuggerStepThrough);
 				}
 			} catch (Exception innerException) when (!(innerException is OperationCanceledException)) {
-				throw new DecompilerException(typeSystem.ModuleDefinition, (MethodDefinitionHandle)method.MetadataToken, innerException);
+				throw new DecompilerException(module.PEFile, (MethodDefinitionHandle)method.MetadataToken, innerException);
 			}
 		}
 
@@ -1154,12 +1146,12 @@ namespace ICSharpCode.Decompiler.CSharp
 				RemoveAttribute(fixedFieldDecl, KnownAttribute.FixedBuffer);
 				return fixedFieldDecl;
 			}
-			var fieldDefinition = typeSystem.GetMetadata().GetFieldDefinition((FieldDefinitionHandle)field.MetadataToken);
+			var fieldDefinition = metadata.GetFieldDefinition((FieldDefinitionHandle)field.MetadataToken);
 			if (fieldDefinition.HasFlag(System.Reflection.FieldAttributes.HasFieldRVA)) {
 				// Field data as specified in II.16.3.2 of ECMA-335 6th edition:
 				// .data I_X = int32(123)
 				// .field public static int32 _x at I_X
-				var initVal = fieldDefinition.GetInitialValue(typeSystem.ModuleDefinition.Reader, TypeSystem);
+				var initVal = fieldDefinition.GetInitialValue(module.PEFile.Reader, TypeSystem);
 				var message = string.Format(" Not supported: data({0}) ", BitConverter.ToString(initVal.ReadBytes(initVal.RemainingBytes)).Replace('-', ' '));
 				((FieldDeclaration)fieldDecl).Variables.Single().AddChild(new Comment(message, CommentType.MultiLine), Roles.Comment);
 			}
@@ -1205,7 +1197,6 @@ namespace ICSharpCode.Decompiler.CSharp
 			if (property.CanSet && property.Setter.HasBody) {
 				DecompileBody(property.Setter, setter, decompileRun, decompilationContext);
 			}
-			var metadata = typeSystem.GetMetadata();
 			var accessorHandle = (MethodDefinitionHandle)(property.Getter ?? property.Setter).MetadataToken;
 			var accessor = metadata.GetMethodDefinition(accessorHandle);
 			if (!accessorHandle.GetMethodImplementations(metadata).Any() && accessor.HasFlag(System.Reflection.MethodAttributes.Virtual) == accessor.HasFlag(System.Reflection.MethodAttributes.NewSlot))
@@ -1223,7 +1214,6 @@ namespace ICSharpCode.Decompiler.CSharp
 			if (ev.IsExplicitInterfaceImplementation) {
 				eventDecl.Name = ev.Name.Substring(lastDot + 1);
 			}
-			var metadata = typeSystem.ModuleDefinition.Metadata;
 			if (ev.CanAdd && ev.AddAccessor.HasBody) {
 				DecompileBody(ev.AddAccessor, ((CustomEventDeclaration)eventDecl).AddAccessor, decompileRun, decompilationContext);
 			}

ICSharpCode.Decompiler/CSharp/RequiredNamespaceCollector.cs

@@ -20,21 +20,23 @@ namespace ICSharpCode.Decompiler.CSharp
 {
 	class RequiredNamespaceCollector
 	{
-		public static void CollectNamespaces(DecompilerTypeSystem typeSystem, HashSet<string> namespaces)
+		public static void CollectNamespaces(MetadataModule module, HashSet<string> namespaces)
 		{
-			foreach (var type in typeSystem.MainModule.TypeDefinitions) {
-				CollectNamespaces(type, typeSystem, namespaces);
+			foreach (var type in module.TypeDefinitions) {
+				CollectNamespaces(type, module, namespaces);
 			}
-			CollectAttributeNamespaces(typeSystem, namespaces);
+			CollectAttributeNamespaces(module, namespaces);
 		}
 
-		public static void CollectAttributeNamespaces(DecompilerTypeSystem typeSystem, HashSet<string> namespaces)
+		public static void CollectAttributeNamespaces(MetadataModule module, HashSet<string> namespaces)
 		{
-			HandleAttributes(typeSystem.MainModule.GetAssemblyAttributes(), namespaces);
-			HandleAttributes(typeSystem.MainModule.GetModuleAttributes(), namespaces);
+			HandleAttributes(module.GetAssemblyAttributes(), namespaces);
+			HandleAttributes(module.GetModuleAttributes(), namespaces);
 		}
 
-		public static void CollectNamespaces(IEntity entity, DecompilerTypeSystem typeSystem,
+		static readonly Decompiler.TypeSystem.GenericContext genericContext = default;
+
+		public static void CollectNamespaces(IEntity entity, MetadataModule module,
 			HashSet<string> namespaces, CodeMappingInfo mappingInfo = null, bool scanningFullType = false)
 		{
 			if (entity == null || entity.MetadataToken.IsNil)
@@ -55,23 +57,23 @@ namespace ICSharpCode.Decompiler.CSharp
 					}
 
 					foreach (var nestedType in td.NestedTypes) {
-						CollectNamespaces(nestedType, typeSystem, namespaces, mappingInfo, scanningFullType: true);
+						CollectNamespaces(nestedType, module, namespaces, mappingInfo, scanningFullType: true);
 					}
 
 					foreach (var field in td.Fields) {
-						CollectNamespaces(field, typeSystem, namespaces, mappingInfo, scanningFullType: true);
+						CollectNamespaces(field, module, namespaces, mappingInfo, scanningFullType: true);
 					}
 
 					foreach (var property in td.Properties) {
-						CollectNamespaces(property, typeSystem, namespaces, mappingInfo, scanningFullType: true);
+						CollectNamespaces(property, module, namespaces, mappingInfo, scanningFullType: true);
 					}
 
 					foreach (var @event in td.Events) {
-						CollectNamespaces(@event, typeSystem, namespaces, mappingInfo, scanningFullType: true);
+						CollectNamespaces(@event, module, namespaces, mappingInfo, scanningFullType: true);
 					}
 
 					foreach (var method in td.Methods) {
-						CollectNamespaces(method, typeSystem, namespaces, mappingInfo, scanningFullType: true);
+						CollectNamespaces(method, module, namespaces, mappingInfo, scanningFullType: true);
 					}
 					break;
 				case IField field:
@@ -92,24 +94,24 @@ namespace ICSharpCode.Decompiler.CSharp
 					if (!method.MetadataToken.IsNil && method.HasBody) {
 						if (mappingInfo == null)
 							mappingInfo = CSharpDecompiler.GetCodeMappingInfo(entity.ParentModule.PEFile, entity.MetadataToken);
-						var reader = typeSystem.ModuleDefinition.Reader;
+						var reader = module.PEFile.Reader;
 						var parts = mappingInfo.GetMethodParts((MethodDefinitionHandle)method.MetadataToken).ToList();
 						foreach (var part in parts) {
-							var methodDef = typeSystem.ModuleDefinition.Metadata.GetMethodDefinition(part);
+							var methodDef = module.metadata.GetMethodDefinition(part);
 							var body = reader.GetMethodBody(methodDef.RelativeVirtualAddress);
-							CollectNamespacesFromMethodBody(body, reader, typeSystem, namespaces, scanningFullType: scanningFullType);
+							CollectNamespacesFromMethodBody(body, module, namespaces, scanningFullType: scanningFullType);
 						}
 					}
 					break;
 				case IProperty property:
 					HandleAttributes(property.GetAttributes(), namespaces);
-					CollectNamespaces(property.Getter, typeSystem, namespaces);
-					CollectNamespaces(property.Setter, typeSystem, namespaces);
+					CollectNamespaces(property.Getter, module, namespaces);
+					CollectNamespaces(property.Setter, module, namespaces);
 					break;
 				case IEvent @event:
 					HandleAttributes(@event.GetAttributes(), namespaces);
-					CollectNamespaces(@event.AddAccessor, typeSystem, namespaces);
-					CollectNamespaces(@event.RemoveAccessor, typeSystem, namespaces);
+					CollectNamespaces(@event.AddAccessor, module, namespaces);
+					CollectNamespaces(@event.RemoveAccessor, module, namespaces);
 					break;
 			}
 		}
@@ -137,14 +139,10 @@ namespace ICSharpCode.Decompiler.CSharp
 			}
 		}
 
-		public static void CollectNamespaces(EntityHandle entity, DecompilerTypeSystem typeSystem, HashSet<string> namespaces)
+		public static void CollectNamespaces(EntityHandle entity, MetadataModule module, HashSet<string> namespaces)
 		{
 			if (entity.IsNil) return;
-			if (entity.Kind.IsTypeKind()) {
-				CollectNamespaces(typeSystem.ResolveAsType(entity).GetDefinition(), typeSystem, namespaces);
-			} else {
-				CollectNamespaces(typeSystem.ResolveAsMember(entity), typeSystem, namespaces);
-			}
+			CollectNamespaces(module.ResolveEntity(entity, genericContext), module, namespaces);
 		}
 
 		public static void HandleAttributes(IEnumerable<IAttribute> attributes, HashSet<string> namespaces)
@@ -172,20 +170,20 @@ namespace ICSharpCode.Decompiler.CSharp
 			}
 		}
 
-		static void CollectNamespacesFromMethodBody(MethodBodyBlock method, PEReader reader, DecompilerTypeSystem typeSystem, HashSet<string> namespaces, bool scanningFullType = false)
+		static void CollectNamespacesFromMethodBody(MethodBodyBlock method, MetadataModule module, HashSet<string> namespaces, bool scanningFullType = false)
 		{
+			var metadata = module.metadata;
 			var instructions = method.GetILReader();
-			var metadata = reader.GetMetadataReader();
 
 			if (!method.LocalSignature.IsNil) {
-				var localSignature = typeSystem.DecodeLocalSignature(method.LocalSignature);
+				var localSignature = module.DecodeLocalSignature(method.LocalSignature, genericContext);
 				foreach (var type in localSignature)
 					CollectNamespacesForTypeReference(type, namespaces);
 			}
 
 			foreach (var region in method.ExceptionRegions) {
 				if (region.CatchType.IsNil) continue;
-				CollectNamespacesForTypeReference(typeSystem.ResolveAsType(region.CatchType), namespaces);
+				CollectNamespacesForTypeReference(module.ResolveType(region.CatchType, genericContext), namespaces);
 			}
 
 			while (instructions.RemainingBytes > 0) {
@@ -202,18 +200,19 @@ namespace ICSharpCode.Decompiler.CSharp
 							case HandleKind.TypeDefinition:
 							case HandleKind.TypeReference:
 							case HandleKind.TypeSpecification:
-								CollectNamespacesForTypeReference(typeSystem.ResolveAsType(handle), namespaces);
+								CollectNamespacesForTypeReference(module.ResolveType(handle, genericContext), namespaces);
 								break;
 							case HandleKind.FieldDefinition:
 							case HandleKind.MethodDefinition:
 							case HandleKind.MethodSpecification:
 							case HandleKind.MemberReference:
-								CollectNamespacesForMemberReference(typeSystem.ResolveAsMember(handle), typeSystem, namespaces, scanningFullType: scanningFullType);
+								CollectNamespacesForMemberReference(module.ResolveEntity(handle, genericContext) as IMember,
+									module, namespaces, scanningFullType: scanningFullType);
 								break;
 							case HandleKind.StandaloneSignature:
 								var sig = metadata.GetStandaloneSignature((StandaloneSignatureHandle)handle);
 								if (sig.GetKind() == StandaloneSignatureKind.Method) {
-									var methodSig = typeSystem.DecodeMethodSignature((StandaloneSignatureHandle)handle);
+									var methodSig = module.DecodeMethodSignature((StandaloneSignatureHandle)handle, genericContext);
 									CollectNamespacesForTypeReference(methodSig.ReturnType, namespaces);
 									foreach (var paramType in methodSig.ParameterTypes) {
 										CollectNamespacesForTypeReference(paramType, namespaces);
@@ -229,19 +228,19 @@ namespace ICSharpCode.Decompiler.CSharp
 			}
 		}
 
-		static void CollectNamespacesForMemberReference(IMember member, DecompilerTypeSystem typeSystem, HashSet<string> namespaces, bool scanningFullType = false)
+		static void CollectNamespacesForMemberReference(IMember member, MetadataModule module, HashSet<string> namespaces, bool scanningFullType = false)
 		{
 			switch (member) {
 				case IField field:
 					if (!scanningFullType && field.IsCompilerGeneratedOrIsInCompilerGeneratedClass())
-						CollectNamespaces(field, typeSystem, namespaces);
+						CollectNamespaces(field, module, namespaces);
 					else
 						CollectNamespacesForTypeReference(field.DeclaringType, namespaces);
 					CollectNamespacesForTypeReference(field.ReturnType, namespaces);
 					break;
 				case IMethod method:
 					if (!scanningFullType && method.IsCompilerGeneratedOrIsInCompilerGeneratedClass())
-						CollectNamespaces(method, typeSystem, namespaces);
+						CollectNamespaces(method, module, namespaces);
 					else
 						CollectNamespacesForTypeReference(method.DeclaringType, namespaces);
 					CollectNamespacesForTypeReference(method.ReturnType, namespaces);

ICSharpCode.Decompiler/CSharp/Transforms/ConvertConstructorCallIntoInitializer.cs

@@ -188,7 +188,7 @@ namespace ICSharpCode.Decompiler.CSharp.Transforms
 			if (staticCtor != null) {
 				IMethod ctorMethod = staticCtor.GetSymbol() as IMethod;
 				if (!ctorMethod.MetadataToken.IsNil) {
-					var metadata = context.TypeSystem.ModuleDefinition.Metadata;
+					var metadata = context.TypeSystem.MainModule.PEFile.Metadata;
 					SRM.MethodDefinition ctorMethodDef = metadata.GetMethodDefinition((SRM.MethodDefinitionHandle)ctorMethod.MetadataToken);
 					SRM.TypeDefinition declaringType = metadata.GetTypeDefinition(ctorMethodDef.GetDeclaringType());
 					if (declaringType.HasFlag(System.Reflection.TypeAttributes.BeforeFieldInit)) {

ICSharpCode.Decompiler/CSharp/Transforms/TransformContext.cs

@@ -28,7 +28,7 @@ namespace ICSharpCode.Decompiler.CSharp.Transforms
 	/// </summary>
 	public class TransformContext
 	{
-		public readonly DecompilerTypeSystem TypeSystem;
+		public readonly IDecompilerTypeSystem TypeSystem;
 		public readonly CancellationToken CancellationToken;
 		public readonly TypeSystemAstBuilder TypeSystemAstBuilder;
 		public readonly DecompilerSettings Settings;
@@ -62,7 +62,7 @@ namespace ICSharpCode.Decompiler.CSharp.Transforms
 		/// </summary>
 		public IImmutableSet<string> RequiredNamespacesSuperset => DecompileRun.Namespaces.ToImmutableHashSet();
 
-		internal TransformContext(DecompilerTypeSystem typeSystem, DecompileRun decompileRun, ITypeResolveContext decompilationContext, TypeSystemAstBuilder typeSystemAstBuilder)
+		internal TransformContext(IDecompilerTypeSystem typeSystem, DecompileRun decompileRun, ITypeResolveContext decompilationContext, TypeSystemAstBuilder typeSystemAstBuilder)
 		{
 			this.TypeSystem = typeSystem;
 			this.DecompileRun = decompileRun;

ICSharpCode.Decompiler/CSharp/WholeProjectDecompiler.cs

@@ -278,7 +278,7 @@ namespace ICSharpCode.Decompiler.CSharp
 
 		CSharpDecompiler CreateDecompiler(DecompilerTypeSystem ts)
 		{
-			var decompiler = new CSharpDecompiler(ts, AssemblyResolver, settings);
+			var decompiler = new CSharpDecompiler(ts, settings);
 			decompiler.AstTransforms.Add(new EscapeInvalidIdentifiers());
 			decompiler.AstTransforms.Add(new RemoveCLSCompliantAttribute());
 			return decompiler;

ICSharpCode.Decompiler/IL/ControlFlow/AsyncAwaitDecompiler.cs

@@ -62,7 +62,6 @@ namespace ICSharpCode.Decompiler.IL.ControlFlow
 		}
 
 		ILTransformContext context;
-		MetadataReader metadata;
 
 		// These fields are set by MatchTaskCreationPattern()
 		IType taskType; // return type of the async method
@@ -98,7 +97,6 @@ namespace ICSharpCode.Decompiler.IL.ControlFlow
 			if (!context.Settings.AsyncAwait)
 				return; // abort if async/await decompilation is disabled
 			this.context = context;
-			this.metadata = context.TypeSystem.GetMetadata();
 			fieldToParameterMap.Clear();
 			cachedFieldToParameterMap.Clear();
 			awaitBlocks.Clear();
@@ -334,7 +332,9 @@ namespace ICSharpCode.Decompiler.IL.ControlFlow
 		{
 			if (stateMachineType.MetadataToken.IsNil)
 				throw new SymbolicAnalysisFailedException();
-			var moveNextMethod = metadata.GetTypeDefinition((TypeDefinitionHandle)stateMachineType.MetadataToken).GetMethods().FirstOrDefault(f => metadata.GetString(metadata.GetMethodDefinition(f).Name)== "MoveNext");
+			var metadata = context.PEFile.Metadata;
+			var moveNextMethod = metadata.GetTypeDefinition((TypeDefinitionHandle)stateMachineType.MetadataToken)
+				.GetMethods().FirstOrDefault(f => metadata.GetString(metadata.GetMethodDefinition(f).Name) == "MoveNext");
 			if (moveNextMethod == null)
 				throw new SymbolicAnalysisFailedException();
 			moveNextFunction = YieldReturnDecompiler.CreateILAst(moveNextMethod, context);

ICSharpCode.Decompiler/IL/ControlFlow/YieldReturnDecompiler.cs

@@ -106,7 +106,7 @@ namespace ICSharpCode.Decompiler.IL.ControlFlow
 			if (!context.Settings.YieldReturn)
 				return; // abort if enumerator decompilation is disabled
 			this.context = context;
-			this.metadata = context.TypeSystem.GetMetadata();
+			this.metadata = context.PEFile.Metadata;
 			this.currentType = metadata.GetMethodDefinition((MethodDefinitionHandle)context.Function.Method.MetadataToken).GetDeclaringType();
 			this.enumeratorType = default;
 			this.enumeratorCtor = default;
@@ -364,8 +364,7 @@ namespace ICSharpCode.Decompiler.IL.ControlFlow
 		/// </summary>
 		internal static ILFunction CreateILAst(MethodDefinitionHandle method, ILTransformContext context)
 		{
-			var typeSystem = context.TypeSystem;
-			var metadata = typeSystem.GetMetadata();
+			var metadata = context.PEFile.Metadata;
 			if (method.IsNil)
 				throw new SymbolicAnalysisFailedException();
 
@@ -382,7 +381,7 @@ namespace ICSharpCode.Decompiler.IL.ControlFlow
 			var il = context.CreateILReader()
 				.ReadIL(method, body, genericContext, context.CancellationToken);
 			il.RunTransforms(CSharpDecompiler.EarlyILTransforms(true),
-				new ILTransformContext(il, typeSystem, context.DebugInfo, context.Settings) {
+				new ILTransformContext(il, context.TypeSystem, context.DebugInfo, context.Settings) {
 					CancellationToken = context.CancellationToken,
 					DecompileRun = context.DecompileRun
 				});

ICSharpCode.Decompiler/IL/Transforms/DelegateConstruction.cs

@@ -159,15 +159,14 @@ namespace ICSharpCode.Decompiler.IL.Transforms
 			target = value.Arguments[0];
 			if (targetMethod.MetadataToken.IsNil)
 				return null;
-			var metadata = context.TypeSystem.GetMetadata();
-			var methodDefinition = metadata.GetMethodDefinition((MethodDefinitionHandle)targetMethod.MetadataToken);
+			var methodDefinition = context.PEFile.Metadata.GetMethodDefinition((MethodDefinitionHandle)targetMethod.MetadataToken);
 			if (!methodDefinition.HasBody())
 				return null;
 			var genericContext = GenericContextFromTypeArguments(targetMethod.Substitution);
 			if (genericContext == null)
 				return null;
 			var ilReader = context.CreateILReader();
-			var body = context.TypeSystem.ModuleDefinition.Reader.GetMethodBody(methodDefinition.RelativeVirtualAddress);
+			var body = context.PEFile.Reader.GetMethodBody(methodDefinition.RelativeVirtualAddress);
 			var function = ilReader.ReadIL((MethodDefinitionHandle)targetMethod.MetadataToken, body, genericContext.Value, context.CancellationToken);
 			function.DelegateType = value.Method.DeclaringType;
 			function.CheckInvariant(ILPhase.Normal);

ICSharpCode.Decompiler/IL/Transforms/IILTransform.cs

@@ -47,6 +47,7 @@ namespace ICSharpCode.Decompiler.IL.Transforms
 		public DecompilerSettings Settings { get; }
 		public CancellationToken CancellationToken { get; set; }
 		public Stepper Stepper { get; set; }
+		public Metadata.PEFile PEFile => TypeSystem.MainModule.PEFile;
 
 		internal DecompileRun DecompileRun { get; set; }
 		internal ResolvedUsingScope UsingScope => DecompileRun.UsingScope.Resolve(TypeSystem.Compilation);
@@ -71,7 +72,10 @@ namespace ICSharpCode.Decompiler.IL.Transforms
 			this.Stepper = context.Stepper;
 		}
 
-		public ILReader CreateILReader()
+		/// <summary>
+		/// Creates a new ILReader instance for decompiling another method in the same assembly.
+		/// </summary>
+		internal ILReader CreateILReader()
 		{
 			return new ILReader(TypeSystem.MainModule) {
 				UseDebugSymbols = Settings.UseDebugSymbols,

ICSharpCode.Decompiler/IL/Transforms/ProxyCallReplacer.cs

@@ -24,8 +24,7 @@ namespace ICSharpCode.Decompiler.IL.Transforms
 				return;
 			if (!inst.Method.IsCompilerGeneratedOrIsInCompilerGeneratedClass())
 				return;
-			var module = context.TypeSystem.ModuleDefinition;
-			var metadata = module.Metadata;
+			var metadata = context.PEFile.Metadata;
 			MethodDefinition methodDef = metadata.GetMethodDefinition((MethodDefinitionHandle)inst.Method.MetadataToken);
 			if (!methodDef.HasBody())
 				return;
@@ -34,7 +33,7 @@ namespace ICSharpCode.Decompiler.IL.Transforms
 				return;
 			// partially copied from CSharpDecompiler
 			var ilReader = context.CreateILReader();
-			var body = module.Reader.GetMethodBody(methodDef.RelativeVirtualAddress);
+			var body = context.PEFile.Reader.GetMethodBody(methodDef.RelativeVirtualAddress);
 			var proxyFunction = ilReader.ReadIL(handle, body, genericContext.Value, context.CancellationToken);
 			var transformContext = new ILTransformContext(context, proxyFunction);
 			proxyFunction.RunTransforms(CSharp.CSharpDecompiler.EarlyILTransforms(), transformContext);

ICSharpCode.Decompiler/IL/Transforms/TransformArrayInitializers.cs

@@ -308,7 +308,7 @@ namespace ICSharpCode.Decompiler.IL.Transforms
 			return true;
 		}
 		
-		bool MatchInitializeArrayCall(ILInstruction instruction, out IMethod method, out ILVariable array, out System.Reflection.Metadata.FieldDefinition field)
+		bool MatchInitializeArrayCall(ILInstruction instruction, out IMethod method, out ILVariable array, out FieldDefinition field)
 		{
 			method = null;
 			array = null;
@@ -328,7 +328,7 @@ namespace ICSharpCode.Decompiler.IL.Transforms
 				return false;
 			if (member.MetadataToken.IsNil)
 				return false;
-			field = context.TypeSystem.GetMetadata().GetFieldDefinition((System.Reflection.Metadata.FieldDefinitionHandle)member.MetadataToken);
+			field = context.PEFile.Metadata.GetFieldDefinition((FieldDefinitionHandle)member.MetadataToken);
 			return true;
 		}
 
@@ -337,7 +337,7 @@ namespace ICSharpCode.Decompiler.IL.Transforms
 			if (MatchInitializeArrayCall(body.Instructions[pos], out var method, out var v2, out var field) && array == v2) {
 				if (field.HasFlag(System.Reflection.FieldAttributes.HasFieldRVA)) {
 					var valuesList = new List<ILInstruction>();
-					var initialValue = field.GetInitialValue(context.TypeSystem.ModuleDefinition.Reader, context.TypeSystem);
+					var initialValue = field.GetInitialValue(context.PEFile.Reader, context.TypeSystem);
 					if (DecodeArrayInitializer(arrayType, array, initialValue, arrayLength, valuesList)) {
 						values = valuesList.ToArray();
 						foundPos = pos;

ICSharpCode.Decompiler/Metadata/MetadataExtensions.cs

@@ -205,14 +205,6 @@ namespace ICSharpCode.Decompiler.Metadata
 			}
 		}
 
-		public static AssemblyDefinition? GetAssemblyDefinition(this PEReader reader)
-		{
-			var metadata = reader.GetMetadataReader();
-			if (metadata.IsAssembly)
-				return metadata.GetAssemblyDefinition();
-			return null;
-		}
-
 		public static IEnumerable<ModuleReferenceHandle> GetModuleReferences(this MetadataReader metadata)
 		{
 			var rowCount = metadata.GetTableRowCount(TableIndex.ModuleRef);

ICSharpCode.Decompiler/SRMExtensions.cs

@@ -342,24 +342,25 @@ namespace ICSharpCode.Decompiler
 			return pefile.GetSectionData(rva).GetReader(0, size);
 		}
 
-		class FieldValueSizeDecoder : ISignatureTypeProvider<int, Unit>
+		sealed class FieldValueSizeDecoder : ISignatureTypeProvider<int, GenericContext>
 		{
-			IDecompilerTypeSystem typeSystem;
+			MetadataModule module;
 
 			public FieldValueSizeDecoder(IDecompilerTypeSystem typeSystem)
 			{
-				this.typeSystem = typeSystem ?? throw new ArgumentNullException(nameof(typeSystem));
+				this.module = typeSystem.MainModule;
 			}
 
-			public int GetArrayType(int elementType, ArrayShape shape) => elementType;
-			public int GetByReferenceType(int elementType) => elementType;
-			public int GetFunctionPointerType(MethodSignature<int> signature) => IntPtr.Size;
+			public int GetArrayType(int elementType, ArrayShape shape) => GetPrimitiveType(PrimitiveTypeCode.Object);
+			public int GetSZArrayType(int elementType) => GetPrimitiveType(PrimitiveTypeCode.Object);
+			public int GetByReferenceType(int elementType) => GetPointerType(elementType);
+			public int GetFunctionPointerType(MethodSignature<int> signature) => GetPrimitiveType(PrimitiveTypeCode.IntPtr);
 			public int GetGenericInstantiation(int genericType, ImmutableArray<int> typeArguments) => genericType;
-			public int GetGenericMethodParameter(Unit genericContext, int index) => 0;
-			public int GetGenericTypeParameter(Unit genericContext, int index) => 0;
+			public int GetGenericMethodParameter(GenericContext genericContext, int index) => 0;
+			public int GetGenericTypeParameter(GenericContext genericContext, int index) => 0;
 			public int GetModifiedType(int modifier, int unmodifiedType, bool isRequired) => unmodifiedType;
 			public int GetPinnedType(int elementType) => elementType;
-			public int GetPointerType(int elementType) => elementType;
+			public int GetPointerType(int elementType) => GetPrimitiveType(PrimitiveTypeCode.IntPtr);
 
 			public int GetPrimitiveType(PrimitiveTypeCode typeCode) 
 			{
@@ -382,16 +383,13 @@ namespace ICSharpCode.Decompiler
 						return 8;
 					case PrimitiveTypeCode.IntPtr:
 					case PrimitiveTypeCode.UIntPtr:
-						// this is the same as Cecil does.
+						// This is the same as Cecil does, but probably not a good idea.
 						return IntPtr.Size;
 					default:
-						// we assume pointer size for object, string and typedref
-						return IntPtr.Size;
+						return 0;
 				}
 			}
 
-			public int GetSZArrayType(int elementType) => 0;
-
 			public int GetTypeFromDefinition(MetadataReader reader, TypeDefinitionHandle handle, byte rawTypeKind)
 			{
 				var td = reader.GetTypeDefinition(handle);
@@ -400,7 +398,7 @@ namespace ICSharpCode.Decompiler
 
 			public int GetTypeFromReference(MetadataReader reader, TypeReferenceHandle handle, byte rawTypeKind)
 			{
-				var typeDef = typeSystem.ResolveAsType(handle).GetDefinition();
+				var typeDef = module.ResolveType(handle, new GenericContext()).GetDefinition();
 				if (typeDef == null || typeDef.MetadataToken.IsNil)
 					return 0;
 				reader = typeDef.ParentModule.PEFile.Metadata;
@@ -408,14 +406,9 @@ namespace ICSharpCode.Decompiler
 				return td.GetLayout().Size;
 			}
 
-			public int GetTypeFromSpecification(MetadataReader reader, Unit genericContext, TypeSpecificationHandle handle, byte rawTypeKind)
+			public int GetTypeFromSpecification(MetadataReader reader, GenericContext genericContext, TypeSpecificationHandle handle, byte rawTypeKind)
 			{
-				var typeDef = typeSystem.ResolveAsType(handle).GetDefinition();
-				if (typeDef == null || typeDef.MetadataToken.IsNil)
-					return 0;
-				reader = typeDef.ParentModule.PEFile.Metadata;
-				var td = reader.GetTypeDefinition((TypeDefinitionHandle)typeDef.MetadataToken);
-				return td.GetLayout().Size;
+				return reader.GetTypeSpecification(handle).DecodeSignature(this, genericContext);
 			}
 		}
 	}

ICSharpCode.Decompiler/TypeSystem/DecompilerTypeSystem.cs

@@ -173,96 +173,5 @@ namespace ICSharpCode.Decompiler.TypeSystem
 			get { return moduleDefinition; }
 		}
 
-		public SRM.MetadataReader GetMetadata() => moduleDefinition.Metadata;
-		
-		public IMember ResolveAsMember(SRM.EntityHandle memberReference)
-		{
-			switch (memberReference.Kind) {
-				case SRM.HandleKind.FieldDefinition:
-					return ResolveAsField(memberReference);
-				case SRM.HandleKind.MethodDefinition:
-					return ResolveAsMethod(memberReference);
-				case SRM.HandleKind.MemberReference:
-					var mr = moduleDefinition.Metadata.GetMemberReference((SRM.MemberReferenceHandle)memberReference);
-					switch (mr.GetKind()) {
-						case SRM.MemberReferenceKind.Method:
-							return ResolveAsMethod(memberReference);
-						case SRM.MemberReferenceKind.Field:
-							return ResolveAsField(memberReference);
-					}
-					throw new BadImageFormatException("MemberReference must be either a method or a field");
-				case SRM.HandleKind.EventDefinition:
-					return ResolveAsEvent(memberReference);
-				case SRM.HandleKind.PropertyDefinition:
-					return ResolveAsProperty(memberReference);
-				case SRM.HandleKind.MethodSpecification:
-					return ResolveAsMethod(memberReference);
-				default:
-					throw new ArgumentOutOfRangeException(nameof(memberReference), "HandleKind not allowed: " + memberReference.Kind);
-			}
-		}
-
-		public IType ResolveAsType(SRM.EntityHandle typeReference)
-		{
-			return mainModule.ResolveType(typeReference, new GenericContext());
-		}
-
-		public IMethod ResolveAsMethod(SRM.EntityHandle methodReference)
-		{
-			return mainModule.ResolveMethod(methodReference);
-		}
-
-		public IField ResolveAsField(SRM.EntityHandle fieldReference)
-		{
-			return mainModule.ResolveEntity(fieldReference, new GenericContext()) as IField;
-		}
-
-		public IProperty ResolveAsProperty(SRM.EntityHandle propertyReference)
-		{
-			return mainModule.ResolveEntity(propertyReference, new GenericContext()) as IProperty;
-		}
-
-		public IEvent ResolveAsEvent(SRM.EntityHandle eventReference)
-		{
-			return mainModule.ResolveEntity(eventReference, new GenericContext()) as IEvent;
-		}
-
-		public SRM.MethodSignature<IType> DecodeMethodSignature(SRM.StandaloneSignatureHandle handle)
-		{
-			var standaloneSignature = moduleDefinition.Metadata.GetStandaloneSignature(handle);
-			if (standaloneSignature.GetKind() != SRM.StandaloneSignatureKind.Method)
-				throw new InvalidOperationException("Expected Method signature");
-			var sig = standaloneSignature.DecodeMethodSignature(
-				mainModule.TypeProvider,
-				new GenericContext()
-			);
-			return new SRM.MethodSignature<IType>(
-				sig.Header,
-				ApplyAttributesToType(sig.ReturnType),
-				sig.RequiredParameterCount,
-				sig.GenericParameterCount,
-				ImmutableArray.CreateRange(
-					sig.ParameterTypes, ApplyAttributesToType
-				)
-			);
-		}
-
-		public ImmutableArray<IType> DecodeLocalSignature(SRM.StandaloneSignatureHandle handle)
-		{
-			var standaloneSignature = moduleDefinition.Metadata.GetStandaloneSignature(handle);
-			if (standaloneSignature.GetKind() != SRM.StandaloneSignatureKind.LocalVariables)
-				throw new InvalidOperationException("Expected Local signature");
-			var types = standaloneSignature.DecodeLocalSignature(
-				mainModule.TypeProvider,
-				new GenericContext()
-			);
-			return ImmutableArray.CreateRange(types, ApplyAttributesToType);
-		}
-
-		IType ApplyAttributesToType(IType t)
-		{
-			return ApplyAttributeTypeVisitor.ApplyAttributesToType(t, compilation, null,
-				moduleDefinition.Metadata, typeSystemOptions);
-		}
 	}
 }

ICSharpCode.Decompiler/TypeSystem/IDecompilerTypeSystem.cs

@@ -29,16 +29,5 @@ namespace ICSharpCode.Decompiler.TypeSystem
 	{
 		ICompilation Compilation { get; }
 		MetadataModule MainModule { get; }
-
-		MethodSignature<IType> DecodeMethodSignature(StandaloneSignatureHandle standaloneSignatureHandle);
-		ImmutableArray<IType> DecodeLocalSignature(StandaloneSignatureHandle standaloneSignatureHandle);
-
-		IType ResolveAsType(EntityHandle typeReference);
-		IField ResolveAsField(EntityHandle fieldReference);
-		IMethod ResolveAsMethod(EntityHandle methodReference);
-		IMember ResolveAsMember(EntityHandle memberReference);
-
-		MetadataReader GetMetadata();
-		PEFile ModuleDefinition { get; }
 	}
 }

ICSharpCode.Decompiler/TypeSystem/Implementation/AttributeListBuilder.cs

@@ -173,7 +173,8 @@ namespace ICSharpCode.Decompiler.TypeSystem.Implementation
 			var metadata = module.metadata;
 			foreach (var handle in attributes) {
 				var attribute = metadata.GetCustomAttribute(handle);
-				var ctor = module.ResolveMethod(attribute.Constructor);
+				// Attribute types shouldn't be generic (and certainly not open), so we don't need a generic context.
+				var ctor = module.ResolveMethod(attribute.Constructor, new GenericContext());
 				var type = ctor.DeclaringType;
 				if (IgnoreAttribute(type)) {
 					continue;

ICSharpCode.Decompiler/TypeSystem/MetadataModule.cs

@@ -298,7 +298,7 @@ namespace ICSharpCode.Decompiler.TypeSystem
 		#endregion
 
 		#region Resolve Method
-		public IMethod ResolveMethod(EntityHandle methodReference, GenericContext context = default)
+		public IMethod ResolveMethod(EntityHandle methodReference, GenericContext context)
 		{
 			if (methodReference.IsNil)
 				throw new ArgumentNullException(nameof(methodReference));

ILSpy/Analyzers/Builtin/FieldAccessAnalyzer.cs

@@ -74,6 +74,7 @@ namespace ICSharpCode.ILSpy.Analyzers.Builtin
 		{
 			bool found = false;
 			var blob = methodBody.GetILReader();
+			var genericContext = new Decompiler.TypeSystem.GenericContext(); // type parameters don't matter for this analyzer
 
 			while (!found && blob.RemainingBytes > 0) {
 				var opCode = blob.DecodeOpCode();
@@ -84,7 +85,7 @@ namespace ICSharpCode.ILSpy.Analyzers.Builtin
 				EntityHandle fieldHandle = MetadataTokenHelpers.EntityHandleOrNil(blob.ReadInt32());
 				if (!fieldHandle.Kind.IsMemberKind())
 					continue;
-				var field = context.TypeSystem.ResolveAsField(fieldHandle);
+				var field = context.TypeSystem.MainModule.ResolveEntity(fieldHandle, genericContext) as IField;
 				if (field == null)
 					continue;
 

ILSpy/Analyzers/Builtin/MethodUsedByAnalyzer.cs

@@ -42,6 +42,7 @@ namespace ICSharpCode.ILSpy.Analyzers.Builtin
 			var blob = methodBody.GetILReader();
 
 			var baseMethod = InheritanceHelper.GetBaseMember(analyzedMethod);
+			var genericContext = new Decompiler.TypeSystem.GenericContext(); // type parameters don't matter for this analyzer
 
 			while (blob.RemainingBytes > 0) {
 				var opCode = blob.DecodeOpCode();
@@ -52,7 +53,7 @@ namespace ICSharpCode.ILSpy.Analyzers.Builtin
 				var member = MetadataTokenHelpers.EntityHandleOrNil(blob.ReadInt32());
 				if (member.IsNil || !member.Kind.IsMemberKind()) continue;
 
-				var m = context.TypeSystem.ResolveAsMember(member)?.MemberDefinition;
+				var m = (context.TypeSystem.MainModule.ResolveEntity(member, genericContext) as IMember)?.MemberDefinition;
 				if (m == null) continue;
 
 				if (opCode == ILOpCode.Call) {

ILSpy/Analyzers/Builtin/MethodVirtualUsedByAnalyzer.cs

@@ -40,6 +40,7 @@ namespace ICSharpCode.ILSpy.Analyzers.Builtin
 		public IEnumerable<IEntity> Analyze(IMethod analyzedMethod, IMethod method, MethodBodyBlock methodBody, AnalyzerContext context)
 		{
 			var blob = methodBody.GetILReader();
+			var genericContext = new Decompiler.TypeSystem.GenericContext();
 
 			while (blob.RemainingBytes > 0) {
 				var opCode = blob.DecodeOpCode();
@@ -55,7 +56,7 @@ namespace ICSharpCode.ILSpy.Analyzers.Builtin
 							case HandleKind.MethodDefinition:
 							case HandleKind.MethodSpecification:
 							case HandleKind.MemberReference:
-								var m = context.TypeSystem.ResolveAsMember(member)?.MemberDefinition;
+								var m = (context.TypeSystem.MainModule.ResolveEntity(member, genericContext) as IMember)?.MemberDefinition;
 								if (m.MetadataToken == analyzedMethod.MetadataToken && m.ParentModule.PEFile == analyzedMethod.ParentModule.PEFile) {
 									yield return method;
 									yield break;

ILSpy/Analyzers/Builtin/TypeInstantiatedByAnalyzer.cs

@@ -42,6 +42,7 @@ namespace ICSharpCode.ILSpy.Analyzers.Builtin
 		{
 			bool found = false;
 			var blob = methodBody.GetILReader();
+			var genericContext = new Decompiler.TypeSystem.GenericContext(); // type parameters don't matter for this analyzer
 
 			while (!found && blob.RemainingBytes > 0) {
 				var opCode = blob.DecodeOpCode();
@@ -52,7 +53,7 @@ namespace ICSharpCode.ILSpy.Analyzers.Builtin
 				EntityHandle methodHandle = MetadataTokenHelpers.EntityHandleOrNil(blob.ReadInt32());
 				if (!methodHandle.Kind.IsMemberKind())
 					continue;
-				var ctor = context.TypeSystem.ResolveAsMethod(methodHandle);
+				var ctor = context.TypeSystem.MainModule.ResolveMethod(methodHandle, genericContext);
 				if (ctor == null || !ctor.IsConstructor)
 					continue;
 

ILSpy/Analyzers/Builtin/TypeUsedByAnalyzer.cs

@@ -38,11 +38,12 @@ namespace ICSharpCode.ILSpy.Analyzers.Builtin
 
 		public IEnumerable<IEntity> Analyze(ITypeDefinition analyzedEntity, IMethod method, MethodBodyBlock methodBody, AnalyzerContext context)
 		{
-			var typeSystem = context.TypeSystem;
+			var module = context.TypeSystem.MainModule;
 			var visitor = new TypeDefinitionUsedVisitor(analyzedEntity);
+			var genericContext = new Decompiler.TypeSystem.GenericContext(); // type parameters don't matter for this analyzer
 
 			if (!methodBody.LocalSignature.IsNil) {
-				foreach (var type in typeSystem.DecodeLocalSignature(methodBody.LocalSignature)) {
+				foreach (var type in module.DecodeLocalSignature(methodBody.LocalSignature, genericContext)) {
 					type.AcceptVisitor(visitor);
 
 					if (visitor.Found) {
@@ -68,7 +69,7 @@ namespace ICSharpCode.ILSpy.Analyzers.Builtin
 							case HandleKind.TypeReference:
 							case HandleKind.TypeSpecification:
 							case HandleKind.TypeDefinition:
-								typeSystem.ResolveAsType(member).AcceptVisitor(visitor);
+								module.ResolveType(member, genericContext).AcceptVisitor(visitor);
 								if (visitor.Found) {
 									yield return method;
 									yield break;
@@ -79,7 +80,7 @@ namespace ICSharpCode.ILSpy.Analyzers.Builtin
 							case HandleKind.MethodDefinition:
 							case HandleKind.MemberReference:
 							case HandleKind.MethodSpecification:
-								VisitMember(visitor, typeSystem.ResolveAsMember(member));
+								VisitMember(visitor, module.ResolveEntity(member, genericContext) as IMember);
 
 								if (visitor.Found) {
 									yield return method;
@@ -88,7 +89,7 @@ namespace ICSharpCode.ILSpy.Analyzers.Builtin
 								break;
 
 							case HandleKind.StandaloneSignature:
-								var signature = typeSystem.DecodeMethodSignature((StandaloneSignatureHandle)member);
+								var signature = module.DecodeMethodSignature((StandaloneSignatureHandle)member, genericContext);
 								foreach (var type in signature.ParameterTypes) {
 									type.AcceptVisitor(visitor);
 								}

ILSpy/Analyzers/ScopedWhereUsedAnalyzer.cs

@@ -258,7 +258,7 @@ namespace ICSharpCode.ILSpy.Analyzers
 				var parentHandle = context.CodeMappingInfo.GetParentMethod((MethodDefinitionHandle)entity.MetadataToken);
 				if (entity.MetadataToken == parentHandle)
 					return entity;
-				var method = context.TypeSystem.ResolveAsMethod(parentHandle);
+				var method = context.TypeSystem.MainModule.ResolveMethod(parentHandle, new Decompiler.TypeSystem.GenericContext());
 				if (method != null) {
 					return method.AccessorOwner ?? method;
 				}

ILSpy/LoadedAssembly.cs

@@ -118,7 +118,10 @@ namespace ICSharpCode.ILSpy
 		public string Text {
 			get {
 				if (IsLoaded && !HasLoadError) {
-					string version = GetPEFileOrNull()?.Reader.GetAssemblyDefinition()?.Version.ToString();
+					var metadata = GetPEFileOrNull()?.Metadata;
+					string version = null;
+					if (metadata != null && metadata.IsAssembly)
+						version = metadata.GetAssemblyDefinition().Version?.ToString();
 					if (version == null)
 						return ShortName;
 					return String.Format("{0} ({1})", ShortName, version);