diff --git a/ICSharpCode.Decompiler/Disassembler/DisassemblerSignatureTypeProvider.cs b/ICSharpCode.Decompiler/Disassembler/DisassemblerSignatureTypeProvider.cs new file mode 100644 index 000000000..7954ab2b5 --- /dev/null +++ b/ICSharpCode.Decompiler/Disassembler/DisassemblerSignatureTypeProvider.cs @@ -0,0 +1,262 @@ +// Copyright (c) 2011 AlphaSierraPapa for the SharpDevelop Team +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System; +using System.Collections.Immutable; +using System.Reflection.Metadata; + +using ICSharpCode.Decompiler.Metadata; +using ICSharpCode.Decompiler.IL; + +namespace ICSharpCode.Decompiler.Disassembler +{ + public class DisassemblerSignatureTypeProvider : ISignatureTypeProvider, GenericContext> + { + readonly PEFile module; + readonly MetadataReader metadata; + readonly ITextOutput output; + + public DisassemblerSignatureTypeProvider(PEFile module, ITextOutput output) + { + this.module = module ?? throw new ArgumentNullException(nameof(module)); + this.output = output ?? throw new ArgumentNullException(nameof(output)); + this.metadata = module.Metadata; + } + + public Action GetArrayType(Action elementType, ArrayShape shape) + { + return syntax => { + var syntaxForElementTypes = syntax == ILNameSyntax.SignatureNoNamedTypeParameters ? syntax : ILNameSyntax.Signature; + elementType(syntaxForElementTypes); + output.Write('['); + for (int i = 0; i < shape.Rank; i++) { + if (i > 0) + output.Write(", "); + if (i < shape.LowerBounds.Length || i < shape.Sizes.Length) { + int lower = 0; + if (i < shape.LowerBounds.Length) { + lower = shape.LowerBounds[i]; + output.Write(lower.ToString()); + } + output.Write("..."); + if (i < shape.Sizes.Length) + output.Write((lower + shape.Sizes[i] - 1).ToString()); + } + } + output.Write(']'); + }; + } + + public Action GetByReferenceType(Action elementType) + { + return syntax => { + var syntaxForElementTypes = syntax == ILNameSyntax.SignatureNoNamedTypeParameters ? syntax : ILNameSyntax.Signature; + elementType(syntaxForElementTypes); + output.Write('&'); + }; + } + + public Action GetFunctionPointerType(MethodSignature> signature) + { + return syntax => { + output.Write("method "); + signature.ReturnType(syntax); + output.Write(" *("); + for (int i = 0; i < signature.ParameterTypes.Length; i++) { + if (i > 0) + output.Write(", "); + signature.ParameterTypes[i](syntax); + } + output.Write(')'); + }; + } + + public Action GetGenericInstantiation(Action genericType, ImmutableArray> typeArguments) + { + return syntax => { + var syntaxForElementTypes = syntax == ILNameSyntax.SignatureNoNamedTypeParameters ? syntax : ILNameSyntax.Signature; + genericType(syntaxForElementTypes); + output.Write('<'); + for (int i = 0; i < typeArguments.Length; i++) { + if (i > 0) + output.Write(", "); + typeArguments[i](syntaxForElementTypes); + } + output.Write('>'); + }; + } + + public Action GetGenericMethodParameter(GenericContext genericContext, int index) + { + return syntax => { + output.Write("!!"); + WriteTypeParameter(genericContext.GetGenericMethodTypeParameterHandleOrNull(index), index, syntax); + }; + } + + public Action GetGenericTypeParameter(GenericContext genericContext, int index) + { + return syntax => { + output.Write("!"); + WriteTypeParameter(genericContext.GetGenericTypeParameterHandleOrNull(index), index, syntax); + }; + } + + void WriteTypeParameter(GenericParameterHandle paramRef, int index, ILNameSyntax syntax) + { + if (paramRef.IsNil || syntax == ILNameSyntax.SignatureNoNamedTypeParameters) + output.Write(index.ToString()); + else { + var param = metadata.GetGenericParameter(paramRef); + if (param.Name.IsNil) + output.Write(param.Index.ToString()); + else + output.Write(DisassemblerHelpers.Escape(metadata.GetString(param.Name))); + } + } + + public Action GetModifiedType(Action modifier, Action unmodifiedType, bool isRequired) + { + return syntax => { + unmodifiedType(syntax); + if (isRequired) + output.Write(" modreq"); + else + output.Write(" modopt"); + output.Write('('); + modifier(ILNameSyntax.TypeName); + output.Write(')'); + }; + } + + public Action GetPinnedType(Action elementType) + { + return syntax => { + var syntaxForElementTypes = syntax == ILNameSyntax.SignatureNoNamedTypeParameters ? syntax : ILNameSyntax.Signature; + elementType(syntaxForElementTypes); + output.Write(" pinned"); + }; + } + + public Action GetPointerType(Action elementType) + { + return syntax => { + var syntaxForElementTypes = syntax == ILNameSyntax.SignatureNoNamedTypeParameters ? syntax : ILNameSyntax.Signature; + elementType(syntaxForElementTypes); + output.Write('*'); + }; + } + + public Action GetPrimitiveType(PrimitiveTypeCode typeCode) + { + switch (typeCode) { + case PrimitiveTypeCode.SByte: + return syntax => output.Write("int8"); + case PrimitiveTypeCode.Int16: + return syntax => output.Write("int16"); + case PrimitiveTypeCode.Int32: + return syntax => output.Write("int32"); + case PrimitiveTypeCode.Int64: + return syntax => output.Write("int64"); + case PrimitiveTypeCode.Byte: + return syntax => output.Write("uint8"); + case PrimitiveTypeCode.UInt16: + return syntax => output.Write("uint16"); + case PrimitiveTypeCode.UInt32: + return syntax => output.Write("uint32"); + case PrimitiveTypeCode.UInt64: + return syntax => output.Write("uint64"); + case PrimitiveTypeCode.Single: + return syntax => output.Write("float32"); + case PrimitiveTypeCode.Double: + return syntax => output.Write("float64"); + case PrimitiveTypeCode.Void: + return syntax => output.Write("void"); + case PrimitiveTypeCode.Boolean: + return syntax => output.Write("bool"); + case PrimitiveTypeCode.String: + return syntax => output.Write("string"); + case PrimitiveTypeCode.Char: + return syntax => output.Write("char"); + case PrimitiveTypeCode.Object: + return syntax => output.Write("object"); + case PrimitiveTypeCode.IntPtr: + return syntax => output.Write("native int"); + case PrimitiveTypeCode.UIntPtr: + return syntax => output.Write("native uint"); + case PrimitiveTypeCode.TypedReference: + return syntax => output.Write("typedref"); + default: + throw new ArgumentOutOfRangeException(); + } + } + + public Action GetSZArrayType(Action elementType) + { + return syntax => { + var syntaxForElementTypes = syntax == ILNameSyntax.SignatureNoNamedTypeParameters ? syntax : ILNameSyntax.Signature; + elementType(syntaxForElementTypes); + output.Write('['); + output.Write(']'); + }; + } + + public Action GetTypeFromDefinition(MetadataReader reader, TypeDefinitionHandle handle, byte rawTypeKind) + { + return syntax => { + switch (rawTypeKind) { + case 0x00: + break; + case 0x11: + output.Write("valuetype "); + break; + case 0x12: + output.Write("class "); + break; + default: + throw new BadImageFormatException($"Unexpected rawTypeKind: {rawTypeKind} (0x{rawTypeKind:x})"); + } + ((EntityHandle)handle).WriteTo(module, output, GenericContext.Empty); + }; + } + + public Action GetTypeFromReference(MetadataReader reader, TypeReferenceHandle handle, byte rawTypeKind) + { + return syntax => { + switch (rawTypeKind) { + case 0x00: + break; + case 0x11: + output.Write("valuetype "); + break; + case 0x12: + output.Write("class "); + break; + default: + throw new BadImageFormatException($"Unexpected rawTypeKind: {rawTypeKind} (0x{rawTypeKind:x})"); + } + ((EntityHandle)handle).WriteTo(module, output, GenericContext.Empty); + }; + } + + public Action GetTypeFromSpecification(MetadataReader reader, GenericContext genericContext, TypeSpecificationHandle handle, byte rawTypeKind) + { + return reader.GetTypeSpecification(handle).DecodeSignature(this, genericContext); + } + } +} \ No newline at end of file diff --git a/ICSharpCode.Decompiler/Disassembler/MethodBodyDisassembler.cs b/ICSharpCode.Decompiler/Disassembler/MethodBodyDisassembler.cs index f93e3962e..f0a76b663 100644 --- a/ICSharpCode.Decompiler/Disassembler/MethodBodyDisassembler.cs +++ b/ICSharpCode.Decompiler/Disassembler/MethodBodyDisassembler.cs @@ -69,7 +69,7 @@ namespace ICSharpCode.Decompiler.Disassembler PEFile module; MetadataReader metadata; GenericContext genericContext; - DisassemblerSignatureProvider signatureDecoder; + DisassemblerSignatureTypeProvider signatureDecoder; public MethodBodyDisassembler(ITextOutput output, CancellationToken cancellationToken) { @@ -82,7 +82,7 @@ namespace ICSharpCode.Decompiler.Disassembler this.module = module ?? throw new ArgumentNullException(nameof(module)); metadata = module.Metadata; genericContext = new GenericContext(handle, module); - signatureDecoder = new DisassemblerSignatureProvider(module, output); + signatureDecoder = new DisassemblerSignatureTypeProvider(module, output); var methodDefinition = metadata.GetMethodDefinition(handle); // start writing IL code @@ -171,7 +171,7 @@ namespace ICSharpCode.Decompiler.Disassembler this.module = module; metadata = module.Metadata; genericContext = new GenericContext(handle, module); - signatureDecoder = new DisassemblerSignatureProvider(module, output); + signatureDecoder = new DisassemblerSignatureTypeProvider(module, output); var handlers = body.ExceptionRegions; if (!handlers.IsEmpty) { output.WriteLine(); diff --git a/ICSharpCode.Decompiler/Disassembler/ReflectionDisassembler.cs b/ICSharpCode.Decompiler/Disassembler/ReflectionDisassembler.cs index 2f9712599..258255e0c 100644 --- a/ICSharpCode.Decompiler/Disassembler/ReflectionDisassembler.cs +++ b/ICSharpCode.Decompiler/Disassembler/ReflectionDisassembler.cs @@ -227,7 +227,7 @@ namespace ICSharpCode.Decompiler.Disassembler var declaringType = methodDefinition.GetDeclaringType(); MethodSignature>? signature; try { - var signatureProvider = new DisassemblerSignatureProvider(module, output); + var signatureProvider = new DisassemblerSignatureTypeProvider(module, output); signature = methodDefinition.DecodeSignature(signatureProvider, genericContext); if (signature.Value.Header.HasExplicitThis) { output.Write("instance explicit "); @@ -1115,7 +1115,7 @@ namespace ICSharpCode.Decompiler.Disassembler const FieldAttributes hasXAttributes = FieldAttributes.HasDefault | FieldAttributes.HasFieldMarshal | FieldAttributes.HasFieldRVA; WriteFlags(fieldDefinition.Attributes & ~(FieldAttributes.FieldAccessMask | hasXAttributes), fieldAttributes); - var signature = fieldDefinition.DecodeSignature(new DisassemblerSignatureProvider(module, output), new GenericContext(fieldDefinition.GetDeclaringType(), module)); + var signature = fieldDefinition.DecodeSignature(new DisassemblerSignatureTypeProvider(module, output), new GenericContext(fieldDefinition.GetDeclaringType(), module)); var marshallingDescriptor = fieldDefinition.GetMarshallingDescriptor(); if (!marshallingDescriptor.IsNil) { @@ -1210,7 +1210,7 @@ namespace ICSharpCode.Decompiler.Disassembler WriteFlags(propertyDefinition.Attributes, propertyAttributes); var accessors = propertyDefinition.GetAccessors(); var declaringType = metadata.GetMethodDefinition(accessors.GetAny()).GetDeclaringType(); - var signature = propertyDefinition.DecodeSignature(new DisassemblerSignatureProvider(module, output), new GenericContext(declaringType, module)); + var signature = propertyDefinition.DecodeSignature(new DisassemblerSignatureTypeProvider(module, output), new GenericContext(declaringType, module)); if (signature.Header.IsInstance) output.Write("instance "); @@ -1273,7 +1273,7 @@ namespace ICSharpCode.Decompiler.Disassembler output.WriteReference(module, handle, ".event", true); output.Write(" "); WriteFlags(eventDefinition.Attributes, eventAttributes); - var provider = new DisassemblerSignatureProvider(module, output); + var provider = new DisassemblerSignatureTypeProvider(module, output); Action signature; switch (eventDefinition.Type.Kind) { case HandleKind.TypeDefinition: @@ -1758,239 +1758,4 @@ namespace ICSharpCode.Decompiler.Disassembler } } } - - class DisassemblerSignatureProvider : ISignatureTypeProvider, GenericContext> - { - readonly PEFile module; - readonly MetadataReader metadata; - readonly ITextOutput output; - - public DisassemblerSignatureProvider(PEFile module, ITextOutput output) - { - this.module = module ?? throw new ArgumentNullException(nameof(module)); - this.output = output ?? throw new ArgumentNullException(nameof(output)); - this.metadata = module.Metadata; - } - - public Action GetArrayType(Action elementType, ArrayShape shape) - { - return syntax => { - var syntaxForElementTypes = syntax == ILNameSyntax.SignatureNoNamedTypeParameters ? syntax : ILNameSyntax.Signature; - elementType(syntaxForElementTypes); - output.Write('['); - for (int i = 0; i < shape.Rank; i++) { - if (i > 0) - output.Write(", "); - if (i < shape.LowerBounds.Length || i < shape.Sizes.Length) { - int lower = 0; - if (i < shape.LowerBounds.Length) { - lower = shape.LowerBounds[i]; - output.Write(lower.ToString()); - } - output.Write("..."); - if (i < shape.Sizes.Length) - output.Write((lower + shape.Sizes[i] - 1).ToString()); - } - } - output.Write(']'); - }; - } - - public Action GetByReferenceType(Action elementType) - { - return syntax => { - var syntaxForElementTypes = syntax == ILNameSyntax.SignatureNoNamedTypeParameters ? syntax : ILNameSyntax.Signature; - elementType(syntaxForElementTypes); - output.Write('&'); - }; - } - - public Action GetFunctionPointerType(MethodSignature> signature) - { - return syntax => { - output.Write("method "); - signature.ReturnType(syntax); - output.Write(" *("); - for (int i = 0; i < signature.ParameterTypes.Length; i++) { - if (i > 0) - output.Write(", "); - signature.ParameterTypes[i](syntax); - } - output.Write(')'); - }; - } - - public Action GetGenericInstantiation(Action genericType, ImmutableArray> typeArguments) - { - return syntax => { - var syntaxForElementTypes = syntax == ILNameSyntax.SignatureNoNamedTypeParameters ? syntax : ILNameSyntax.Signature; - genericType(syntaxForElementTypes); - output.Write('<'); - for (int i = 0; i < typeArguments.Length; i++) { - if (i > 0) - output.Write(", "); - typeArguments[i](syntaxForElementTypes); - } - output.Write('>'); - }; - } - - public Action GetGenericMethodParameter(GenericContext genericContext, int index) - { - return syntax => { - output.Write("!!"); - WriteTypeParameter(genericContext.GetGenericMethodTypeParameterHandleOrNull(index), index, syntax); - }; - } - - public Action GetGenericTypeParameter(GenericContext genericContext, int index) - { - return syntax => { - output.Write("!"); - WriteTypeParameter(genericContext.GetGenericTypeParameterHandleOrNull(index), index, syntax); - }; - } - - void WriteTypeParameter(GenericParameterHandle paramRef, int index, ILNameSyntax syntax) - { - if (paramRef.IsNil || syntax == ILNameSyntax.SignatureNoNamedTypeParameters) - output.Write(index.ToString()); - else { - var param = metadata.GetGenericParameter(paramRef); - if (param.Name.IsNil) - output.Write(param.Index.ToString()); - else - output.Write(DisassemblerHelpers.Escape(metadata.GetString(param.Name))); - } - } - - public Action GetModifiedType(Action modifier, Action unmodifiedType, bool isRequired) - { - return syntax => { - unmodifiedType(syntax); - if (isRequired) - output.Write(" modreq"); - else - output.Write(" modopt"); - output.Write('('); - modifier(ILNameSyntax.TypeName); - output.Write(')'); - }; - } - - public Action GetPinnedType(Action elementType) - { - return syntax => { - var syntaxForElementTypes = syntax == ILNameSyntax.SignatureNoNamedTypeParameters ? syntax : ILNameSyntax.Signature; - elementType(syntaxForElementTypes); - output.Write(" pinned"); - }; - } - - public Action GetPointerType(Action elementType) - { - return syntax => { - var syntaxForElementTypes = syntax == ILNameSyntax.SignatureNoNamedTypeParameters ? syntax : ILNameSyntax.Signature; - elementType(syntaxForElementTypes); - output.Write('*'); - }; - } - - public Action GetPrimitiveType(PrimitiveTypeCode typeCode) - { - switch (typeCode) { - case PrimitiveTypeCode.SByte: - return syntax => output.Write("int8"); - case PrimitiveTypeCode.Int16: - return syntax => output.Write("int16"); - case PrimitiveTypeCode.Int32: - return syntax => output.Write("int32"); - case PrimitiveTypeCode.Int64: - return syntax => output.Write("int64"); - case PrimitiveTypeCode.Byte: - return syntax => output.Write("uint8"); - case PrimitiveTypeCode.UInt16: - return syntax => output.Write("uint16"); - case PrimitiveTypeCode.UInt32: - return syntax => output.Write("uint32"); - case PrimitiveTypeCode.UInt64: - return syntax => output.Write("uint64"); - case PrimitiveTypeCode.Single: - return syntax => output.Write("float32"); - case PrimitiveTypeCode.Double: - return syntax => output.Write("float64"); - case PrimitiveTypeCode.Void: - return syntax => output.Write("void"); - case PrimitiveTypeCode.Boolean: - return syntax => output.Write("bool"); - case PrimitiveTypeCode.String: - return syntax => output.Write("string"); - case PrimitiveTypeCode.Char: - return syntax => output.Write("char"); - case PrimitiveTypeCode.Object: - return syntax => output.Write("object"); - case PrimitiveTypeCode.IntPtr: - return syntax => output.Write("native int"); - case PrimitiveTypeCode.UIntPtr: - return syntax => output.Write("native uint"); - case PrimitiveTypeCode.TypedReference: - return syntax => output.Write("typedref"); - default: - throw new ArgumentOutOfRangeException(); - } - } - - public Action GetSZArrayType(Action elementType) - { - return syntax => { - var syntaxForElementTypes = syntax == ILNameSyntax.SignatureNoNamedTypeParameters ? syntax : ILNameSyntax.Signature; - elementType(syntaxForElementTypes); - output.Write('['); - output.Write(']'); - }; - } - - public Action GetTypeFromDefinition(MetadataReader reader, TypeDefinitionHandle handle, byte rawTypeKind) - { - return syntax => { - switch (rawTypeKind) { - case 0x00: - break; - case 0x11: - output.Write("valuetype "); - break; - case 0x12: - output.Write("class "); - break; - default: - throw new BadImageFormatException($"Unexpected rawTypeKind: {rawTypeKind} (0x{rawTypeKind:x})"); - } - ((EntityHandle)handle).WriteTo(module, output, GenericContext.Empty); - }; - } - - public Action GetTypeFromReference(MetadataReader reader, TypeReferenceHandle handle, byte rawTypeKind) - { - return syntax => { - switch (rawTypeKind) { - case 0x00: - break; - case 0x11: - output.Write("valuetype "); - break; - case 0x12: - output.Write("class "); - break; - default: - throw new BadImageFormatException($"Unexpected rawTypeKind: {rawTypeKind} (0x{rawTypeKind:x})"); - } - ((EntityHandle)handle).WriteTo(module, output, GenericContext.Empty); - }; - } - - public Action GetTypeFromSpecification(MetadataReader reader, GenericContext genericContext, TypeSpecificationHandle handle, byte rawTypeKind) - { - return reader.GetTypeSpecification(handle).DecodeSignature(this, genericContext); - } - } } \ No newline at end of file diff --git a/ICSharpCode.Decompiler/ICSharpCode.Decompiler.csproj b/ICSharpCode.Decompiler/ICSharpCode.Decompiler.csproj index 588f877bf..10f7c0cda 100644 --- a/ICSharpCode.Decompiler/ICSharpCode.Decompiler.csproj +++ b/ICSharpCode.Decompiler/ICSharpCode.Decompiler.csproj @@ -63,6 +63,7 @@ + diff --git a/ICSharpCode.Decompiler/IL/InstructionOutputExtensions.cs b/ICSharpCode.Decompiler/IL/InstructionOutputExtensions.cs index b246ac5b9..697389dd1 100644 --- a/ICSharpCode.Decompiler/IL/InstructionOutputExtensions.cs +++ b/ICSharpCode.Decompiler/IL/InstructionOutputExtensions.cs @@ -27,7 +27,7 @@ using ICSharpCode.Decompiler.Util; namespace ICSharpCode.Decompiler.IL { - static partial class InstructionOutputExtensions + public static partial class InstructionOutputExtensions { public static void Write(this ITextOutput output, OpCode opCode) { @@ -118,13 +118,13 @@ namespace ICSharpCode.Decompiler.IL } case HandleKind.TypeSpecification: { var ts = metadata.GetTypeSpecification((TypeSpecificationHandle)entity); - signature = ts.DecodeSignature(new DisassemblerSignatureProvider(module, output), genericContext); + signature = ts.DecodeSignature(new DisassemblerSignatureTypeProvider(module, output), genericContext); signature(syntax); break; } case HandleKind.FieldDefinition: { var fd = metadata.GetFieldDefinition((FieldDefinitionHandle)entity); - signature = fd.DecodeSignature(new DisassemblerSignatureProvider(module, output), new Metadata.GenericContext(fd.GetDeclaringType(), module)); + signature = fd.DecodeSignature(new DisassemblerSignatureTypeProvider(module, output), new Metadata.GenericContext(fd.GetDeclaringType(), module)); signature(ILNameSyntax.SignatureNoNamedTypeParameters); output.Write(' '); ((EntityHandle)fd.GetDeclaringType()).WriteTo(module, output, Metadata.GenericContext.Empty, ILNameSyntax.TypeName); @@ -134,7 +134,7 @@ namespace ICSharpCode.Decompiler.IL } case HandleKind.MethodDefinition: { var md = metadata.GetMethodDefinition((MethodDefinitionHandle)entity); - methodSignature = md.DecodeSignature(new DisassemblerSignatureProvider(module, output), new Metadata.GenericContext((MethodDefinitionHandle)entity, module)); + methodSignature = md.DecodeSignature(new DisassemblerSignatureTypeProvider(module, output), new Metadata.GenericContext((MethodDefinitionHandle)entity, module)); WriteSignatureHeader(output, methodSignature); methodSignature.ReturnType(ILNameSyntax.SignatureNoNamedTypeParameters); output.Write(' '); @@ -192,7 +192,7 @@ namespace ICSharpCode.Decompiler.IL memberName = metadata.GetString(mr.Name); switch (mr.GetKind()) { case MemberReferenceKind.Method: - methodSignature = mr.DecodeMethodSignature(new DisassemblerSignatureProvider(module, output), genericContext); + methodSignature = mr.DecodeMethodSignature(new DisassemblerSignatureTypeProvider(module, output), genericContext); WriteSignatureHeader(output, methodSignature); methodSignature.ReturnType(ILNameSyntax.SignatureNoNamedTypeParameters); output.Write(' '); @@ -202,7 +202,7 @@ namespace ICSharpCode.Decompiler.IL WriteParameterList(output, methodSignature); break; case MemberReferenceKind.Field: - var fieldSignature = mr.DecodeFieldSignature(new DisassemblerSignatureProvider(module, output), genericContext); + var fieldSignature = mr.DecodeFieldSignature(new DisassemblerSignatureTypeProvider(module, output), genericContext); fieldSignature(ILNameSyntax.SignatureNoNamedTypeParameters); output.Write(' '); WriteParent(output, module, metadata, mr.Parent, genericContext, syntax); @@ -213,12 +213,12 @@ namespace ICSharpCode.Decompiler.IL break; case HandleKind.MethodSpecification: var ms = metadata.GetMethodSpecification((MethodSpecificationHandle)entity); - var substitution = ms.DecodeSignature(new DisassemblerSignatureProvider(module, output), genericContext); + var substitution = ms.DecodeSignature(new DisassemblerSignatureTypeProvider(module, output), genericContext); switch (ms.Method.Kind) { case HandleKind.MethodDefinition: var methodDefinition = metadata.GetMethodDefinition((MethodDefinitionHandle)ms.Method); var methodName = metadata.GetString(methodDefinition.Name); - methodSignature = methodDefinition.DecodeSignature(new DisassemblerSignatureProvider(module, output), genericContext); + methodSignature = methodDefinition.DecodeSignature(new DisassemblerSignatureTypeProvider(module, output), genericContext); WriteSignatureHeader(output, methodSignature); methodSignature.ReturnType(ILNameSyntax.SignatureNoNamedTypeParameters); output.Write(' '); @@ -239,7 +239,7 @@ namespace ICSharpCode.Decompiler.IL case HandleKind.MemberReference: var memberReference = metadata.GetMemberReference((MemberReferenceHandle)ms.Method); memberName = metadata.GetString(memberReference.Name); - methodSignature = memberReference.DecodeMethodSignature(new DisassemblerSignatureProvider(module, output), genericContext); + methodSignature = memberReference.DecodeMethodSignature(new DisassemblerSignatureTypeProvider(module, output), genericContext); WriteSignatureHeader(output, methodSignature); methodSignature.ReturnType(ILNameSyntax.SignatureNoNamedTypeParameters); output.Write(' '); @@ -255,7 +255,7 @@ namespace ICSharpCode.Decompiler.IL var standaloneSig = metadata.GetStandaloneSignature((StandaloneSignatureHandle)entity); switch (standaloneSig.GetKind()) { case StandaloneSignatureKind.Method: - methodSignature = standaloneSig.DecodeMethodSignature(new DisassemblerSignatureProvider(module, output), genericContext); + methodSignature = standaloneSig.DecodeMethodSignature(new DisassemblerSignatureTypeProvider(module, output), genericContext); WriteSignatureHeader(output, methodSignature); methodSignature.ReturnType(ILNameSyntax.SignatureNoNamedTypeParameters); WriteParameterList(output, methodSignature); diff --git a/ILSpy/Metadata/CorTables/MethodSpecTableTreeNode.cs b/ILSpy/Metadata/CorTables/MethodSpecTableTreeNode.cs index a58feae98..32e87ad44 100644 --- a/ILSpy/Metadata/CorTables/MethodSpecTableTreeNode.cs +++ b/ILSpy/Metadata/CorTables/MethodSpecTableTreeNode.cs @@ -97,7 +97,7 @@ namespace ICSharpCode.ILSpy.Metadata public string SignatureTooltip { get { ITextOutput output = new PlainTextOutput(); - var signature = methodSpec.DecodeSignature(new DisassemblerSignatureProvider(module, output), GenericContext.Empty); + var signature = methodSpec.DecodeSignature(new DisassemblerSignatureTypeProvider(module, output), GenericContext.Empty); bool first = true; foreach (var type in signature) { if (first) diff --git a/ILSpy/Metadata/CorTables/TypeDefTableTreeNode.cs b/ILSpy/Metadata/CorTables/TypeDefTableTreeNode.cs index 5de470bab..90e214b1f 100644 --- a/ILSpy/Metadata/CorTables/TypeDefTableTreeNode.cs +++ b/ILSpy/Metadata/CorTables/TypeDefTableTreeNode.cs @@ -100,7 +100,7 @@ namespace ICSharpCode.ILSpy.Metadata public string BaseTypeSignature { get { var output = new PlainTextOutput(); - var provider = new DisassemblerSignatureProvider(module, output); + var provider = new DisassemblerSignatureTypeProvider(module, output); if (typeDef.BaseType.IsNil) return null; switch (typeDef.BaseType.Kind) { diff --git a/ILSpy/Metadata/CorTables/TypeSpecTableTreeNode.cs b/ILSpy/Metadata/CorTables/TypeSpecTableTreeNode.cs index 8cf8e4165..a4a335cbc 100644 --- a/ILSpy/Metadata/CorTables/TypeSpecTableTreeNode.cs +++ b/ILSpy/Metadata/CorTables/TypeSpecTableTreeNode.cs @@ -87,7 +87,7 @@ namespace ICSharpCode.ILSpy.Metadata public string SignatureTooltip { get { ITextOutput output = new PlainTextOutput(); - typeSpec.DecodeSignature(new DisassemblerSignatureProvider(module, output), GenericContext.Empty)(ILNameSyntax.Signature); + typeSpec.DecodeSignature(new DisassemblerSignatureTypeProvider(module, output), GenericContext.Empty)(ILNameSyntax.Signature); return output.ToString(); } }