pimhwang
/
ILSpy
mirror of https://github.com/icsharpcode/ILSpy.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

Reorganize extension methods + remove unused/obsolete.

pull/1030/head
Siegfried Pammer 7 years ago
parent
0377f406f8
commit
bc97127d9d
12 changed files with 374 additions and 621 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 17
      ICSharpCode.Decompiler/CSharp/Annotations.cs
  2. 2
      ICSharpCode.Decompiler/CSharp/CSharpDecompiler.cs
  3. 113
      ICSharpCode.Decompiler/CSharp/NRefactoryExtensions.cs
  4. 25
      ICSharpCode.Decompiler/CSharp/Syntax/PatternMatching/INode.cs
  5. 35
      ICSharpCode.Decompiler/CSharp/Syntax/SyntaxExtensions.cs
  6. 1
      ICSharpCode.Decompiler/Disassembler/DisassemblerHelpers.cs
  7. 322
      ICSharpCode.Decompiler/Disassembler/DomExtensions.cs
  8. 2
      ICSharpCode.Decompiler/ICSharpCode.Decompiler.csproj
  9. 295
      ICSharpCode.Decompiler/IL/InstructionOutputExtensions.cs
  10. 131
      ICSharpCode.Decompiler/Metadata/MetadataExtensions.cs
  11. 8
      ICSharpCode.Decompiler/SRMExtensions.cs
  12. 44
      ICSharpCode.Decompiler/SRMHacks.cs

17
ICSharpCode.Decompiler/CSharp/Annotations.cs
Unescape View File

@ -18,6 +18,7 @@ @@ -18,6 +18,7 @@
using System;
using System.Collections.Generic;
using System.Linq;
using ICSharpCode.Decompiler.CSharp.Syntax;
using ICSharpCode.Decompiler.IL;
using ICSharpCode.Decompiler.Semantics;
@ -154,6 +155,22 @@ namespace ICSharpCode.Decompiler.CSharp @@ -154,6 +155,22 @@ namespace ICSharpCode.Decompiler.CSharp
loop.AddAnnotation(new ILVariableResolveResult(v, v.Type));
return loop;
}
public static T CopyAnnotationsFrom<T>(this T node, AstNode other) where T : AstNode
{
foreach (object annotation in other.Annotations) {
node.AddAnnotation(annotation);
}
return node;
}
public static T CopyInstructionsFrom<T>(this T node, AstNode other) where T : AstNode
{
foreach (object annotation in other.Annotations.OfType<ILInstruction>()) {
node.AddAnnotation(annotation);
}
return node;
}
}
public class ILVariableResolveResult : ResolveResult

2
ICSharpCode.Decompiler/CSharp/CSharpDecompiler.cs
Unescape View File

@ -235,7 +235,7 @@ namespace ICSharpCode.Decompiler.CSharp @@ -235,7 +235,7 @@ namespace ICSharpCode.Decompiler.CSharp
case HandleKind.MethodDefinition:
var methodHandle = (MethodDefinitionHandle)member;
var method = metadata.GetMethodDefinition(methodHandle);
var methodSemantics = ((MethodDefinitionHandle)member).GetMethodSemanticsAttributes(metadata);
var methodSemantics = module.MethodSemanticsLookup.GetSemantics(methodHandle).Item2;
if (methodSemantics != 0 && methodSemantics != System.Reflection.MethodSemanticsAttributes.Other)
return true;
if (settings.AnonymousMethods && methodHandle.HasGeneratedName(metadata) && methodHandle.IsCompilerGenerated(metadata))

113
ICSharpCode.Decompiler/CSharp/NRefactoryExtensions.cs
Unescape View File

@ -1,113 +0,0 @@ @@ -1,113 +0,0 @@
// 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.Linq;
using ICSharpCode.Decompiler.CSharp.Syntax;
using ICSharpCode.Decompiler.CSharp.Syntax.PatternMatching;
using ICSharpCode.Decompiler.IL;
namespace ICSharpCode.Decompiler.CSharp
{
static class NRefactoryExtensions
{
[Obsolete("Use the more concrete With...()-methods in AnnotationExtensions, so that we maintain a centralised list of the possible annotation types")]
public static T WithAnnotation<T>(this T node, object annotation) where T : AstNode
{
if (annotation != null)
node.AddAnnotation(annotation);
return node;
}
public static T CopyAnnotationsFrom<T>(this T node, AstNode other) where T : AstNode
{
foreach (object annotation in other.Annotations) {
node.AddAnnotation(annotation);
}
return node;
}
public static T CopyInstructionsFrom<T>(this T node, AstNode other) where T : AstNode
{
foreach (object annotation in other.Annotations.OfType<ILInstruction>()) {
node.AddAnnotation(annotation);
}
return node;
}
public static T Detach<T>(this T node) where T : AstNode
{
node.Remove();
return node;
}
public static Expression WithName(this Expression node, string patternGroupName)
{
return new NamedNode(patternGroupName, node);
}
public static Statement WithName(this Statement node, string patternGroupName)
{
return new NamedNode(patternGroupName, node);
}
public static void AddNamedArgument(this Syntax.Attribute attribute, string name, Expression argument)
{
attribute.Arguments.Add(new AssignmentExpression(new IdentifierExpression(name), argument));
}
public static AstType ToType(this Pattern pattern)
{
return pattern;
}
public static Expression ToExpression(this Pattern pattern)
{
return pattern;
}
public static Statement ToStatement(this Pattern pattern)
{
return pattern;
}
public static Statement GetNextStatement(this Statement statement)
{
AstNode next = statement.NextSibling;
while (next != null && !(next is Statement))
next = next.NextSibling;
return (Statement)next;
}
public static bool IsArgList(this AstType type)
{
var simpleType = type as SimpleType;
return simpleType != null && simpleType.Identifier == "__arglist";
}
/// <summary>
/// Returns true if <paramref name="operatorType"/> is bitwise and, bitwise or, or exclusive or.
/// </summary>
public static bool IsBitwise(this BinaryOperatorType operatorType)
{
return operatorType == BinaryOperatorType.BitwiseAnd
|| operatorType == BinaryOperatorType.BitwiseOr
|| operatorType == BinaryOperatorType.ExclusiveOr;
}
}
}

25
ICSharpCode.Decompiler/CSharp/Syntax/PatternMatching/INode.cs
Unescape View File

@ -65,5 +65,30 @@ namespace ICSharpCode.Decompiler.CSharp.Syntax.PatternMatching @@ -65,5 +65,30 @@ namespace ICSharpCode.Decompiler.CSharp.Syntax.PatternMatching
throw new ArgumentNullException("pattern");
return pattern.DoMatch(other, PatternMatching.Match.CreateNew());
}
public static AstType ToType(this Pattern pattern)
{
return pattern;
}
public static Expression ToExpression(this Pattern pattern)
{
return pattern;
}
public static Statement ToStatement(this Pattern pattern)
{
return pattern;
}
public static Expression WithName(this Expression node, string patternGroupName)
{
return new NamedNode(patternGroupName, node);
}
public static Statement WithName(this Statement node, string patternGroupName)
{
return new NamedNode(patternGroupName, node);
}
}
}

35
ICSharpCode.Decompiler/CSharp/Syntax/SyntaxExtensions.cs
Unescape View File

@ -40,5 +40,40 @@ namespace ICSharpCode.Decompiler.CSharp.Syntax @@ -40,5 +40,40 @@ namespace ICSharpCode.Decompiler.CSharp.Syntax
return false;
}
}
/// <summary>
/// Returns true if <paramref name="operatorType"/> is bitwise and, bitwise or, or exclusive or.
/// </summary>
public static bool IsBitwise(this BinaryOperatorType operatorType)
{
return operatorType == BinaryOperatorType.BitwiseAnd
|| operatorType == BinaryOperatorType.BitwiseOr
|| operatorType == BinaryOperatorType.ExclusiveOr;
}
public static Statement GetNextStatement(this Statement statement)
{
AstNode next = statement.NextSibling;
while (next != null && !(next is Statement))
next = next.NextSibling;
return (Statement)next;
}
public static bool IsArgList(this AstType type)
{
var simpleType = type as SimpleType;
return simpleType != null && simpleType.Identifier == "__arglist";
}
public static void AddNamedArgument(this Syntax.Attribute attribute, string name, Expression argument)
{
attribute.Arguments.Add(new AssignmentExpression(new IdentifierExpression(name), argument));
}
public static T Detach<T>(this T node) where T : AstNode
{
node.Remove();
return node;
}
}
}

1
ICSharpCode.Decompiler/Disassembler/DisassemblerHelpers.cs
Unescape View File

@ -21,6 +21,7 @@ using System.Collections.Generic; @@ -21,6 +21,7 @@ using System.Collections.Generic;
using System.Linq;
using System.Reflection.Metadata;
using System.Text;
using ICSharpCode.Decompiler.IL;
using ICSharpCode.Decompiler.Metadata;
using ICSharpCode.Decompiler.Util;
using SRM = System.Reflection.Metadata;

322
ICSharpCode.Decompiler/Disassembler/DomExtensions.cs
Unescape View File

@ -1,322 +0,0 @@ @@ -1,322 +0,0 @@
// 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;
using System.Reflection.Metadata;
using SRM = System.Reflection.Metadata;
using System.Reflection.Metadata.Ecma335;
using ICSharpCode.Decompiler.Metadata;
using ICSharpCode.Decompiler.Util;
namespace ICSharpCode.Decompiler.Disassembler
{
public static class MetadataExtensions
{
public static void WriteTo(this EntityHandle entity, PEFile module, ITextOutput output, GenericContext genericContext, ILNameSyntax syntax = ILNameSyntax.Signature)
{
if (entity.IsNil)
throw new ArgumentNullException(nameof(entity));
if (module == null)
throw new ArgumentNullException(nameof(module));
var metadata = module.Metadata;
Action<ILNameSyntax> signature;
MethodSignature<Action<ILNameSyntax>> methodSignature;
string memberName;
switch (entity.Kind) {
case HandleKind.TypeDefinition: {
var td = metadata.GetTypeDefinition((TypeDefinitionHandle)entity);
output.WriteReference(module, entity, td.GetFullTypeName(metadata).ToILNameString());
break;
}
case HandleKind.TypeReference: {
var tr = metadata.GetTypeReference((TypeReferenceHandle)entity);
if (!tr.ResolutionScope.IsNil) {
output.Write("[");
var currentTypeRef = tr;
while (currentTypeRef.ResolutionScope.Kind == HandleKind.TypeReference) {
currentTypeRef = metadata.GetTypeReference((TypeReferenceHandle)currentTypeRef.ResolutionScope);
}
switch (currentTypeRef.ResolutionScope.Kind) {
case HandleKind.ModuleDefinition:
var modDef = metadata.GetModuleDefinition();
output.Write(DisassemblerHelpers.Escape(metadata.GetString(modDef.Name)));
break;
case HandleKind.ModuleReference:
break;
case HandleKind.AssemblyReference:
var asmRef = metadata.GetAssemblyReference((AssemblyReferenceHandle)currentTypeRef.ResolutionScope);
output.Write(DisassemblerHelpers.Escape(metadata.GetString(asmRef.Name)));
break;
}
output.Write("]");
}
output.WriteReference(module, entity, entity.GetFullTypeName(metadata).ToILNameString());
break;
}
case HandleKind.TypeSpecification: {
var ts = metadata.GetTypeSpecification((TypeSpecificationHandle)entity);
signature = ts.DecodeSignature(new DisassemblerSignatureProvider(module, output), genericContext);
signature(syntax);
break;
}
case HandleKind.FieldDefinition: {
var fd = metadata.GetFieldDefinition((FieldDefinitionHandle)entity);
signature = fd.DecodeSignature(new DisassemblerSignatureProvider(module, output), new GenericContext(fd.GetDeclaringType(), module));
signature(ILNameSyntax.SignatureNoNamedTypeParameters);
output.Write(' ');
((EntityHandle)fd.GetDeclaringType()).WriteTo(module, output, GenericContext.Empty, ILNameSyntax.TypeName);
output.Write("::");
output.WriteReference(module, entity, DisassemblerHelpers.Escape(metadata.GetString(fd.Name)));
break;
}
case HandleKind.MethodDefinition: {
var md = metadata.GetMethodDefinition((MethodDefinitionHandle)entity);
methodSignature = md.DecodeSignature(new DisassemblerSignatureProvider(module, output), new GenericContext((MethodDefinitionHandle)entity, module));
if (methodSignature.Header.HasExplicitThis) {
output.Write("instance explicit ");
} else if (methodSignature.Header.IsInstance) {
output.Write("instance ");
}
if (methodSignature.Header.CallingConvention == SignatureCallingConvention.VarArgs) {
output.Write("vararg ");
}
methodSignature.ReturnType(ILNameSyntax.SignatureNoNamedTypeParameters);
output.Write(' ');
var declaringType = md.GetDeclaringType();
if (!declaringType.IsNil) {
((EntityHandle)declaringType).WriteTo(module, output, genericContext, ILNameSyntax.TypeName);
output.Write("::");
}
bool isCompilerControlled = (md.Attributes & MethodAttributes.MemberAccessMask) == MethodAttributes.PrivateScope;
if (isCompilerControlled) {
output.WriteReference(module, entity, DisassemblerHelpers.Escape(metadata.GetString(md.Name) + "$PST" + MetadataTokens.GetToken(entity).ToString("X8")));
} else {
output.WriteReference(module, entity, DisassemblerHelpers.Escape(metadata.GetString(md.Name)));
}
var genericParameters = md.GetGenericParameters();
if (genericParameters.Count > 0) {
output.Write('<');
for (int i = 0; i < genericParameters.Count; i++) {
if (i > 0)
output.Write(", ");
var gp = metadata.GetGenericParameter(genericParameters[i]);
if ((gp.Attributes & GenericParameterAttributes.ReferenceTypeConstraint) == GenericParameterAttributes.ReferenceTypeConstraint) {
output.Write("class ");
} else if ((gp.Attributes & GenericParameterAttributes.NotNullableValueTypeConstraint) == GenericParameterAttributes.NotNullableValueTypeConstraint) {
output.Write("valuetype ");
}
if ((gp.Attributes & GenericParameterAttributes.DefaultConstructorConstraint) == GenericParameterAttributes.DefaultConstructorConstraint) {
output.Write(".ctor ");
}
var constraints = gp.GetConstraints();
if (constraints.Count > 0) {
output.Write('(');
for (int j = 0; j < constraints.Count; j++) {
if (j > 0)
output.Write(", ");
var constraint = metadata.GetGenericParameterConstraint(constraints[j]);
constraint.Type.WriteTo(module, output, new GenericContext((MethodDefinitionHandle)entity, module), ILNameSyntax.TypeName);
}
output.Write(") ");
}
if ((gp.Attributes & GenericParameterAttributes.Contravariant) == GenericParameterAttributes.Contravariant) {
output.Write('-');
} else if ((gp.Attributes & GenericParameterAttributes.Covariant) == GenericParameterAttributes.Covariant) {
output.Write('+');
}
output.Write(DisassemblerHelpers.Escape(metadata.GetString(gp.Name)));
}
output.Write('>');
}
output.Write("(");
for (int i = 0; i < methodSignature.ParameterTypes.Length; ++i) {
if (i > 0)
output.Write(", ");
methodSignature.ParameterTypes[i](ILNameSyntax.SignatureNoNamedTypeParameters);
}
output.Write(")");
break;
}
case HandleKind.MemberReference:
var mr = metadata.GetMemberReference((MemberReferenceHandle)entity);
memberName = metadata.GetString(mr.Name);
switch (mr.GetKind()) {
case MemberReferenceKind.Method:
methodSignature = mr.DecodeMethodSignature(new DisassemblerSignatureProvider(module, output), genericContext);
if (methodSignature.Header.HasExplicitThis) {
output.Write("instance explicit ");
} else if (methodSignature.Header.IsInstance) {
output.Write("instance ");
}
if (methodSignature.Header.CallingConvention == SignatureCallingConvention.VarArgs) {
output.Write("vararg ");
}
methodSignature.ReturnType(ILNameSyntax.SignatureNoNamedTypeParameters);
output.Write(' ');
WriteParent(output, module, metadata, mr.Parent, genericContext, syntax);
output.Write("::");
output.WriteReference(module, entity, DisassemblerHelpers.Escape(memberName));
output.Write("(");
for (int i = 0; i < methodSignature.ParameterTypes.Length; ++i) {
if (i > 0)
output.Write(", ");
if (i == methodSignature.RequiredParameterCount)
output.Write("..., ");
methodSignature.ParameterTypes[i](ILNameSyntax.SignatureNoNamedTypeParameters);
}
output.Write(")");
break;
case MemberReferenceKind.Field:
var fieldSignature = mr.DecodeFieldSignature(new DisassemblerSignatureProvider(module, output), genericContext);
fieldSignature(ILNameSyntax.SignatureNoNamedTypeParameters);
output.Write(' ');
WriteParent(output, module, metadata, mr.Parent, genericContext, syntax);
output.Write("::");
output.WriteReference(module, entity, DisassemblerHelpers.Escape(memberName));
break;
}
break;
case HandleKind.MethodSpecification:
var ms = metadata.GetMethodSpecification((MethodSpecificationHandle)entity);
var substitution = ms.DecodeSignature(new DisassemblerSignatureProvider(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);
if (methodSignature.Header.HasExplicitThis) {
output.Write("instance explicit ");
} else if (methodSignature.Header.IsInstance) {
output.Write("instance ");
}
if (methodSignature.Header.CallingConvention == SignatureCallingConvention.VarArgs) {
output.Write("vararg ");
}
methodSignature.ReturnType(ILNameSyntax.SignatureNoNamedTypeParameters);
output.Write(' ');
var declaringType = methodDefinition.GetDeclaringType();
if (!declaringType.IsNil) {
((EntityHandle)declaringType).WriteTo(module, output, genericContext, ILNameSyntax.TypeName);
output.Write("::");
}
bool isCompilerControlled = (methodDefinition.Attributes & MethodAttributes.MemberAccessMask) == MethodAttributes.PrivateScope;
if (isCompilerControlled) {
output.Write(DisassemblerHelpers.Escape(methodName + "$PST" + MetadataTokens.GetToken(ms.Method).ToString("X8")));
} else {
output.Write(DisassemblerHelpers.Escape(methodName));
}
output.Write('<');
for (int i = 0; i < substitution.Length; i++) {
if (i > 0)
output.Write(", ");
substitution[i](syntax);
}
output.Write('>');
output.Write("(");
for (int i = 0; i < methodSignature.ParameterTypes.Length; ++i) {
if (i > 0)
output.Write(", ");
methodSignature.ParameterTypes[i](ILNameSyntax.SignatureNoNamedTypeParameters);
}
output.Write(")");
break;
case HandleKind.MemberReference:
var memberReference = metadata.GetMemberReference((MemberReferenceHandle)ms.Method);
memberName = metadata.GetString(memberReference.Name);
methodSignature = memberReference.DecodeMethodSignature(new DisassemblerSignatureProvider(module, output), genericContext);
if (methodSignature.Header.HasExplicitThis) {
output.Write("instance explicit ");
} else if (methodSignature.Header.IsInstance) {
output.Write("instance ");
}
if (methodSignature.Header.CallingConvention == SignatureCallingConvention.VarArgs) {
output.Write("vararg ");
}
methodSignature.ReturnType(ILNameSyntax.SignatureNoNamedTypeParameters);
output.Write(' ');
WriteParent(output, module, metadata, memberReference.Parent, genericContext, syntax);
output.Write("::");
output.Write(DisassemblerHelpers.Escape(memberName));
output.Write('<');
for (int i = 0; i < substitution.Length; i++) {
if (i > 0)
output.Write(", ");
substitution[i](syntax);
}
output.Write('>');
output.Write("(");
for (int i = 0; i < methodSignature.ParameterTypes.Length; ++i) {
if (i > 0)
output.Write(", ");
methodSignature.ParameterTypes[i](ILNameSyntax.SignatureNoNamedTypeParameters);
}
output.Write(")");
break;
}
break;
case HandleKind.StandaloneSignature:
var standaloneSig = metadata.GetStandaloneSignature((StandaloneSignatureHandle)entity);
switch (standaloneSig.GetKind()) {
case StandaloneSignatureKind.Method:
var methodSig = standaloneSig.DecodeMethodSignature(new DisassemblerSignatureProvider(module, output), genericContext);
methodSig.ReturnType(ILNameSyntax.SignatureNoNamedTypeParameters);
output.Write('(');
for (int i = 0; i < methodSig.ParameterTypes.Length; i++) {
if (i > 0)
output.Write(", ");
methodSig.ParameterTypes[i](ILNameSyntax.SignatureNoNamedTypeParameters);
}
output.Write(')');
break;
case StandaloneSignatureKind.LocalVariables:
default:
output.Write($"@{MetadataTokens.GetToken(entity):X8} /* signature {standaloneSig.GetKind()} */");
break;
}
break;
default:
output.Write($"@{MetadataTokens.GetToken(entity):X8}");
break;
}
}
static void WriteParent(ITextOutput output, PEFile module, MetadataReader metadata, EntityHandle parentHandle, GenericContext genericContext, ILNameSyntax syntax)
{
switch (parentHandle.Kind) {
case HandleKind.MethodDefinition:
var methodDef = metadata.GetMethodDefinition((MethodDefinitionHandle)parentHandle);
((EntityHandle)methodDef.GetDeclaringType()).WriteTo(module, output, genericContext, syntax);
break;
case HandleKind.ModuleReference:
output.Write('[');
var moduleRef = metadata.GetModuleReference((ModuleReferenceHandle)parentHandle);
output.Write(metadata.GetString(moduleRef.Name));
output.Write(']');
break;
case HandleKind.TypeDefinition:
case HandleKind.TypeReference:
case HandleKind.TypeSpecification:
parentHandle.WriteTo(module, output, genericContext, syntax);
break;
}
}
}
}

2
ICSharpCode.Decompiler/ICSharpCode.Decompiler.csproj
Unescape View File

@ -256,7 +256,6 @@ @@ -256,7 +256,6 @@
<Compile Include="CSharp\TranslatedExpression.cs" />
<Compile Include="CSharp\CSharpDecompiler.cs" />
<Compile Include="CSharp\ExpressionBuilder.cs" />
<Compile Include="CSharp\NRefactoryExtensions.cs" />
<Compile Include="CSharp\StatementBuilder.cs" />
<Compile Include="CSharp\Transforms\AddCheckedBlocks.cs" />
<Compile Include="CSharp\Transforms\ConvertConstructorCallIntoInitializer.cs" />
@ -267,7 +266,6 @@ @@ -267,7 +266,6 @@
<Compile Include="CSharp\WholeProjectDecompiler.cs" />
<Compile Include="CSharp\Transforms\AddXmlDocumentationTransform.cs" />
<Compile Include="DecompileRun.cs" />
<Compile Include="Disassembler\DomExtensions.cs" />
<Compile Include="Metadata\AssemblyReferences.cs" />
<Compile Include="Metadata\MetadataTokenHelpers.cs" />
<Compile Include="Disassembler\OpCodeInfo.cs" />

295
ICSharpCode.Decompiler/IL/InstructionOutputExtensions.cs
Unescape View File

@ -16,7 +16,12 @@ @@ -16,7 +16,12 @@
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
// DEALINGS IN THE SOFTWARE.
using System;
using System.Reflection;
using System.Reflection.Metadata;
using System.Reflection.Metadata.Ecma335;
using ICSharpCode.Decompiler.Disassembler;
using ICSharpCode.Decompiler.Metadata;
using ICSharpCode.Decompiler.TypeSystem;
using ICSharpCode.Decompiler.Util;
@ -61,5 +66,295 @@ namespace ICSharpCode.Decompiler.IL @@ -61,5 +66,295 @@ namespace ICSharpCode.Decompiler.IL
else
output.Write($"[{interval.Start:x4}..{interval.InclusiveEnd:x4}] ");
}
public static void WriteTo(this EntityHandle entity, PEFile module, ITextOutput output, Metadata.GenericContext genericContext, ILNameSyntax syntax = ILNameSyntax.Signature)
{
if (entity.IsNil)
throw new ArgumentNullException(nameof(entity));
if (module == null)
throw new ArgumentNullException(nameof(module));
var metadata = module.Metadata;
Action<ILNameSyntax> signature;
MethodSignature<Action<ILNameSyntax>> methodSignature;
string memberName;
switch (entity.Kind) {
case HandleKind.TypeDefinition: {
var td = metadata.GetTypeDefinition((TypeDefinitionHandle)entity);
output.WriteReference(module, entity, td.GetFullTypeName(metadata).ToILNameString());
break;
}
case HandleKind.TypeReference: {
var tr = metadata.GetTypeReference((TypeReferenceHandle)entity);
if (!tr.ResolutionScope.IsNil) {
output.Write("[");
var currentTypeRef = tr;
while (currentTypeRef.ResolutionScope.Kind == HandleKind.TypeReference) {
currentTypeRef = metadata.GetTypeReference((TypeReferenceHandle)currentTypeRef.ResolutionScope);
}
switch (currentTypeRef.ResolutionScope.Kind) {
case HandleKind.ModuleDefinition:
var modDef = metadata.GetModuleDefinition();
output.Write(DisassemblerHelpers.Escape(metadata.GetString(modDef.Name)));
break;
case HandleKind.ModuleReference:
break;
case HandleKind.AssemblyReference:
var asmRef = metadata.GetAssemblyReference((AssemblyReferenceHandle)currentTypeRef.ResolutionScope);
output.Write(DisassemblerHelpers.Escape(metadata.GetString(asmRef.Name)));
break;
}
output.Write("]");
}
output.WriteReference(module, entity, entity.GetFullTypeName(metadata).ToILNameString());
break;
}
case HandleKind.TypeSpecification: {
var ts = metadata.GetTypeSpecification((TypeSpecificationHandle)entity);
signature = ts.DecodeSignature(new DisassemblerSignatureProvider(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(ILNameSyntax.SignatureNoNamedTypeParameters);
output.Write(' ');
((EntityHandle)fd.GetDeclaringType()).WriteTo(module, output, Metadata.GenericContext.Empty, ILNameSyntax.TypeName);
output.Write("::");
output.WriteReference(module, entity, DisassemblerHelpers.Escape(metadata.GetString(fd.Name)));
break;
}
case HandleKind.MethodDefinition: {
var md = metadata.GetMethodDefinition((MethodDefinitionHandle)entity);
methodSignature = md.DecodeSignature(new DisassemblerSignatureProvider(module, output), new Metadata.GenericContext((MethodDefinitionHandle)entity, module));
if (methodSignature.Header.HasExplicitThis) {
output.Write("instance explicit ");
} else if (methodSignature.Header.IsInstance) {
output.Write("instance ");
}
if (methodSignature.Header.CallingConvention == SignatureCallingConvention.VarArgs) {
output.Write("vararg ");
}
methodSignature.ReturnType(ILNameSyntax.SignatureNoNamedTypeParameters);
output.Write(' ');
var declaringType = md.GetDeclaringType();
if (!declaringType.IsNil) {
((EntityHandle)declaringType).WriteTo(module, output, genericContext, ILNameSyntax.TypeName);
output.Write("::");
}
bool isCompilerControlled = (md.Attributes & MethodAttributes.MemberAccessMask) == MethodAttributes.PrivateScope;
if (isCompilerControlled) {
output.WriteReference(module, entity, DisassemblerHelpers.Escape(metadata.GetString(md.Name) + "$PST" + MetadataTokens.GetToken(entity).ToString("X8")));
} else {
output.WriteReference(module, entity, DisassemblerHelpers.Escape(metadata.GetString(md.Name)));
}
var genericParameters = md.GetGenericParameters();
if (genericParameters.Count > 0) {
output.Write('<');
for (int i = 0; i < genericParameters.Count; i++) {
if (i > 0)
output.Write(", ");
var gp = metadata.GetGenericParameter(genericParameters[i]);
if ((gp.Attributes & GenericParameterAttributes.ReferenceTypeConstraint) == GenericParameterAttributes.ReferenceTypeConstraint) {
output.Write("class ");
} else if ((gp.Attributes & GenericParameterAttributes.NotNullableValueTypeConstraint) == GenericParameterAttributes.NotNullableValueTypeConstraint) {
output.Write("valuetype ");
}
if ((gp.Attributes & GenericParameterAttributes.DefaultConstructorConstraint) == GenericParameterAttributes.DefaultConstructorConstraint) {
output.Write(".ctor ");
}
var constraints = gp.GetConstraints();
if (constraints.Count > 0) {
output.Write('(');
for (int j = 0; j < constraints.Count; j++) {
if (j > 0)
output.Write(", ");
var constraint = metadata.GetGenericParameterConstraint(constraints[j]);
constraint.Type.WriteTo(module, output, new Metadata.GenericContext((MethodDefinitionHandle)entity, module), ILNameSyntax.TypeName);
}
output.Write(") ");
}
if ((gp.Attributes & GenericParameterAttributes.Contravariant) == GenericParameterAttributes.Contravariant) {
output.Write('-');
} else if ((gp.Attributes & GenericParameterAttributes.Covariant) == GenericParameterAttributes.Covariant) {
output.Write('+');
}
output.Write(DisassemblerHelpers.Escape(metadata.GetString(gp.Name)));
}
output.Write('>');
}
output.Write("(");
for (int i = 0; i < methodSignature.ParameterTypes.Length; ++i) {
if (i > 0)
output.Write(", ");
methodSignature.ParameterTypes[i](ILNameSyntax.SignatureNoNamedTypeParameters);
}
output.Write(")");
break;
}
case HandleKind.MemberReference:
var mr = metadata.GetMemberReference((MemberReferenceHandle)entity);
memberName = metadata.GetString(mr.Name);
switch (mr.GetKind()) {
case MemberReferenceKind.Method:
methodSignature = mr.DecodeMethodSignature(new DisassemblerSignatureProvider(module, output), genericContext);
if (methodSignature.Header.HasExplicitThis) {
output.Write("instance explicit ");
} else if (methodSignature.Header.IsInstance) {
output.Write("instance ");
}
if (methodSignature.Header.CallingConvention == SignatureCallingConvention.VarArgs) {
output.Write("vararg ");
}
methodSignature.ReturnType(ILNameSyntax.SignatureNoNamedTypeParameters);
output.Write(' ');
WriteParent(output, module, metadata, mr.Parent, genericContext, syntax);
output.Write("::");
output.WriteReference(module, entity, DisassemblerHelpers.Escape(memberName));
output.Write("(");
for (int i = 0; i < methodSignature.ParameterTypes.Length; ++i) {
if (i > 0)
output.Write(", ");
if (i == methodSignature.RequiredParameterCount)
output.Write("..., ");
methodSignature.ParameterTypes[i](ILNameSyntax.SignatureNoNamedTypeParameters);
}
output.Write(")");
break;
case MemberReferenceKind.Field:
var fieldSignature = mr.DecodeFieldSignature(new DisassemblerSignatureProvider(module, output), genericContext);
fieldSignature(ILNameSyntax.SignatureNoNamedTypeParameters);
output.Write(' ');
WriteParent(output, module, metadata, mr.Parent, genericContext, syntax);
output.Write("::");
output.WriteReference(module, entity, DisassemblerHelpers.Escape(memberName));
break;
}
break;
case HandleKind.MethodSpecification:
var ms = metadata.GetMethodSpecification((MethodSpecificationHandle)entity);
var substitution = ms.DecodeSignature(new DisassemblerSignatureProvider(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);
if (methodSignature.Header.HasExplicitThis) {
output.Write("instance explicit ");
} else if (methodSignature.Header.IsInstance) {
output.Write("instance ");
}
if (methodSignature.Header.CallingConvention == SignatureCallingConvention.VarArgs) {
output.Write("vararg ");
}
methodSignature.ReturnType(ILNameSyntax.SignatureNoNamedTypeParameters);
output.Write(' ');
var declaringType = methodDefinition.GetDeclaringType();
if (!declaringType.IsNil) {
((EntityHandle)declaringType).WriteTo(module, output, genericContext, ILNameSyntax.TypeName);
output.Write("::");
}
bool isCompilerControlled = (methodDefinition.Attributes & MethodAttributes.MemberAccessMask) == MethodAttributes.PrivateScope;
if (isCompilerControlled) {
output.Write(DisassemblerHelpers.Escape(methodName + "$PST" + MetadataTokens.GetToken(ms.Method).ToString("X8")));
} else {
output.Write(DisassemblerHelpers.Escape(methodName));
}
output.Write('<');
for (int i = 0; i < substitution.Length; i++) {
if (i > 0)
output.Write(", ");
substitution[i](syntax);
}
output.Write('>');
output.Write("(");
for (int i = 0; i < methodSignature.ParameterTypes.Length; ++i) {
if (i > 0)
output.Write(", ");
methodSignature.ParameterTypes[i](ILNameSyntax.SignatureNoNamedTypeParameters);
}
output.Write(")");
break;
case HandleKind.MemberReference:
var memberReference = metadata.GetMemberReference((MemberReferenceHandle)ms.Method);
memberName = metadata.GetString(memberReference.Name);
methodSignature = memberReference.DecodeMethodSignature(new DisassemblerSignatureProvider(module, output), genericContext);
if (methodSignature.Header.HasExplicitThis) {
output.Write("instance explicit ");
} else if (methodSignature.Header.IsInstance) {
output.Write("instance ");
}
if (methodSignature.Header.CallingConvention == SignatureCallingConvention.VarArgs) {
output.Write("vararg ");
}
methodSignature.ReturnType(ILNameSyntax.SignatureNoNamedTypeParameters);
output.Write(' ');
WriteParent(output, module, metadata, memberReference.Parent, genericContext, syntax);
output.Write("::");
output.Write(DisassemblerHelpers.Escape(memberName));
output.Write('<');
for (int i = 0; i < substitution.Length; i++) {
if (i > 0)
output.Write(", ");
substitution[i](syntax);
}
output.Write('>');
output.Write("(");
for (int i = 0; i < methodSignature.ParameterTypes.Length; ++i) {
if (i > 0)
output.Write(", ");
methodSignature.ParameterTypes[i](ILNameSyntax.SignatureNoNamedTypeParameters);
}
output.Write(")");
break;
}
break;
case HandleKind.StandaloneSignature:
var standaloneSig = metadata.GetStandaloneSignature((StandaloneSignatureHandle)entity);
switch (standaloneSig.GetKind()) {
case StandaloneSignatureKind.Method:
var methodSig = standaloneSig.DecodeMethodSignature(new DisassemblerSignatureProvider(module, output), genericContext);
methodSig.ReturnType(ILNameSyntax.SignatureNoNamedTypeParameters);
output.Write('(');
for (int i = 0; i < methodSig.ParameterTypes.Length; i++) {
if (i > 0)
output.Write(", ");
methodSig.ParameterTypes[i](ILNameSyntax.SignatureNoNamedTypeParameters);
}
output.Write(')');
break;
case StandaloneSignatureKind.LocalVariables:
default:
output.Write($"@{MetadataTokens.GetToken(entity):X8} /* signature {standaloneSig.GetKind()} */");
break;
}
break;
default:
output.Write($"@{MetadataTokens.GetToken(entity):X8}");
break;
}
}
static void WriteParent(ITextOutput output, PEFile module, MetadataReader metadata, EntityHandle parentHandle, Metadata.GenericContext genericContext, ILNameSyntax syntax)
{
switch (parentHandle.Kind) {
case HandleKind.MethodDefinition:
var methodDef = metadata.GetMethodDefinition((MethodDefinitionHandle)parentHandle);
((EntityHandle)methodDef.GetDeclaringType()).WriteTo(module, output, genericContext, syntax);
break;
case HandleKind.ModuleReference:
output.Write('[');
var moduleRef = metadata.GetModuleReference((ModuleReferenceHandle)parentHandle);
output.Write(metadata.GetString(moduleRef.Name));
output.Write(']');
break;
case HandleKind.TypeDefinition:
case HandleKind.TypeReference:
case HandleKind.TypeSpecification:
parentHandle.WriteTo(module, output, genericContext, syntax);
break;
}
}
}
}

131
ICSharpCode.Decompiler/Metadata/MetadataExtensions.cs
Unescape View File

@ -106,18 +106,6 @@ namespace ICSharpCode.Decompiler.Metadata @@ -106,18 +106,6 @@ namespace ICSharpCode.Decompiler.Metadata
}
}
public static bool IsConstructor(this SRM.MethodDefinition methodDefinition, MetadataReader reader)
{
string name = reader.GetString(methodDefinition.Name);
return (methodDefinition.Attributes & (MethodAttributes.RTSpecialName | MethodAttributes.SpecialName)) != 0
&& (name == ".cctor" || name == ".ctor");
}
public static string GetDefaultMemberName(this TypeDefinitionHandle type, MetadataReader reader)
{
return type.GetDefaultMemberName(reader, out var attr);
}
internal static readonly TypeProvider minimalCorlibTypeProvider =
new TypeProvider(new SimpleCompilation(MinimalCorlib.Instance));
@ -129,48 +117,6 @@ namespace ICSharpCode.Decompiler.Metadata @@ -129,48 +117,6 @@ namespace ICSharpCode.Decompiler.Metadata
get => minimalCorlibTypeProvider;
}
public static string GetDefaultMemberName(this TypeDefinitionHandle type, MetadataReader reader, out CustomAttributeHandle defaultMemberAttribute)
{
var td = reader.GetTypeDefinition(type);
foreach (var h in td.GetCustomAttributes()) {
var ca = reader.GetCustomAttribute(h);
if (ca.IsKnownAttribute(reader, KnownAttribute.DefaultMember)) {
var decodedValues = ca.DecodeValue(minimalCorlibTypeProvider);
if (decodedValues.FixedArguments.Length == 1 && decodedValues.FixedArguments[0].Value is string value) {
defaultMemberAttribute = h;
return value;
}
}
}
defaultMemberAttribute = default(CustomAttributeHandle);
return null;
}
public static bool HasOverrides(this MethodDefinitionHandle handle, MetadataReader reader)
{
for (int row = 1; row <= reader.GetTableRowCount(TableIndex.MethodImpl); row++) {
var impl = reader.GetMethodImplementation(MetadataTokens.MethodImplementationHandle(row));
if (impl.MethodBody == handle) return true;
}
return false;
}
public static bool HasParameters(this PropertyDefinitionHandle handle, MetadataReader reader)
{
var a = reader.GetPropertyDefinition(handle).GetAccessors();
if (!a.Getter.IsNil) {
var m = reader.GetMethodDefinition(a.Getter);
return m.GetParameters().Count > 0;
}
if (!a.Setter.IsNil) {
var m = reader.GetMethodDefinition(a.Setter);
return m.GetParameters().Count > 1;
}
return false;
}
public static PrimitiveTypeCode ToPrimitiveTypeCode(this KnownTypeCode typeCode)
{
switch (typeCode) {
@ -259,68 +205,6 @@ namespace ICSharpCode.Decompiler.Metadata @@ -259,68 +205,6 @@ namespace ICSharpCode.Decompiler.Metadata
}
}
public static bool IsSmallReference(this MetadataReader reader, TableIndex table)
{
// TODO detect whether #JTD is present (EnC)
return reader.GetTableRowCount(table) <= ushort.MaxValue;
}
public static int GetReferenceSize(this MetadataReader reader, TableIndex table)
{
return IsSmallReference(reader, table) ? 2 : 4;
}
public static unsafe (int startRow, int endRow) BinarySearchRange(this MetadataReader reader, TableIndex table, int valueOffset, uint referenceValue, bool small)
{
int offset = reader.GetTableMetadataOffset(table);
int rowSize = reader.GetTableRowSize(table);
int rowCount = reader.GetTableRowCount(table);
int tableLength = rowSize * rowCount;
byte* startPointer = reader.MetadataPointer;
int result = BinarySearch();
if (result == -1)
return (-1, -1);
int start = result;
while (start > 0 && GetValue(start - 1) == referenceValue)
start--;
int end = result;
while (end + 1 < tableLength && GetValue(end + 1) == referenceValue)
end++;
return (start, end);
uint GetValue(int row)
{
if (small)
return *(ushort*)(startPointer + offset + row * rowSize + valueOffset);
else
return *(uint*)(startPointer + offset + row * rowSize + valueOffset);
}
int BinarySearch()
{
int startRow = 0;
int endRow = rowCount - 1;
while (startRow <= endRow) {
int row = (startRow + endRow) / 2;
uint currentValue = GetValue(row);
if (referenceValue > currentValue) {
startRow = row + 1;
} else if (referenceValue < currentValue) {
endRow = row - 1;
} else {
return row;
}
}
return -1;
}
}
public static AssemblyDefinition? GetAssemblyDefinition(this PEReader reader)
{
var metadata = reader.GetMetadataReader();
@ -329,21 +213,6 @@ namespace ICSharpCode.Decompiler.Metadata @@ -329,21 +213,6 @@ namespace ICSharpCode.Decompiler.Metadata
return null;
}
public unsafe static ParameterHandle At(this ParameterHandleCollection collection, MetadataReader metadata, int index)
{
if (metadata.GetTableRowCount(TableIndex.ParamPtr) > 0) {
int rowSize = metadata.GetTableRowSize(TableIndex.ParamPtr);
int paramRefSize = (metadata.GetReferenceSize(TableIndex.ParamPtr) > 2) ? 4 : metadata.GetReferenceSize(TableIndex.Param);
int offset = metadata.GetTableMetadataOffset(TableIndex.ParamPtr) + index * rowSize;
byte* ptr = metadata.MetadataPointer + offset;
if (paramRefSize == 2)
return MetadataTokens.ParameterHandle(*(ushort*)ptr);
return MetadataTokens.ParameterHandle((int)*(uint*)ptr);
}
return MetadataTokens.ParameterHandle((index + 1) & 0xFFFFFF);
}
public static IEnumerable<ModuleReferenceHandle> GetModuleReferences(this MetadataReader metadata)
{
var rowCount = metadata.GetTableRowCount(TableIndex.ModuleRef);

8
ICSharpCode.Decompiler/SRMExtensions.cs
Unescape View File

@ -85,14 +85,6 @@ namespace ICSharpCode.Decompiler @@ -85,14 +85,6 @@ namespace ICSharpCode.Decompiler
return !baseType.IsNil && baseType.IsKnownType(reader, KnownTypeCode.MulticastDelegate);
}
public static bool IsExtensionMethod(this MethodDefinition methodDefinition, MetadataReader reader)
{
if (methodDefinition.HasFlag(MethodAttributes.Static)) {
return methodDefinition.GetCustomAttributes().HasKnownAttribute(reader, KnownAttribute.Extension);
}
return false;
}
public static bool HasBody(this MethodDefinition methodDefinition)
{
const MethodAttributes noBodyAttrs = MethodAttributes.Abstract | MethodAttributes.PinvokeImpl;

44
ICSharpCode.Decompiler/SRMHacks.cs
Unescape View File

@ -13,25 +13,6 @@ namespace ICSharpCode.Decompiler @@ -13,25 +13,6 @@ namespace ICSharpCode.Decompiler
{
public static partial class SRMExtensions
{
public static unsafe MethodSemanticsAttributes GetMethodSemanticsAttributes(this MethodDefinitionHandle handle, MetadataReader reader)
{
byte* startPointer = reader.MetadataPointer;
int offset = reader.GetTableMetadataOffset(TableIndex.MethodSemantics);
int rowSize = reader.GetTableRowSize(TableIndex.MethodSemantics);
int rowCount = reader.GetTableRowCount(TableIndex.MethodSemantics);
var small = reader.IsSmallReference(TableIndex.MethodDef);
int methodRowNo = reader.GetRowNumber(handle);
for (int row = rowCount - 1; row >= 0; row--) {
byte* ptr = startPointer + offset + rowSize * row;
uint rowNo = small ? *(ushort*)(ptr + 2) : *(uint*)(ptr + 2);
if (methodRowNo == rowNo) {
return (MethodSemanticsAttributes)(*(ushort*)ptr);
}
}
return 0;
}
public static ImmutableArray<MethodImplementationHandle> GetMethodImplementations(this MethodDefinitionHandle handle, MetadataReader reader)
{
var resultBuilder = ImmutableArray.CreateBuilder<MethodImplementationHandle>();
@ -46,30 +27,5 @@ namespace ICSharpCode.Decompiler @@ -46,30 +27,5 @@ namespace ICSharpCode.Decompiler
return resultBuilder.ToImmutable();
}
/*
internal static unsafe ImmutableArray<(MethodSemanticsAttributes Kind, MethodDefinition Method)> GetAccessors(PEFile module, uint encodedTag)
{
var reader = Module.Metadata;
byte* startPointer = reader.MetadataPointer;
int offset = reader.GetTableMetadataOffset(TableIndex.MethodSemantics);
var methodDefRefSize = reader.GetReferenceSize(TableIndex.MethodDef);
(int startRow, int endRow) = reader.BinarySearchRange(TableIndex.MethodSemantics, 2 + methodDefRefSize, encodedTag, reader.IsSmallReference(TableIndex.MethodSemantics));
if (startRow == -1)
return ImmutableArray<(MethodSemanticsAttributes Kind, MethodDefinition Method)>.Empty;
var methods = new(MethodSemanticsAttributes Kind, MethodDefinition Method)[endRow - startRow + 1];
int rowSize = reader.GetTableRowSize(TableIndex.MethodSemantics);
for (int row = startRow; row <= endRow; row++) {
int rowOffset = row * rowSize;
byte* ptr = startPointer + offset + rowOffset;
var kind = (MethodSemanticsAttributes)(*(ushort*)ptr);
uint rowNo = methodDefRefSize == 2 ? *(ushort*)(ptr + 2) : *(uint*)(ptr + 2);
var handle = MetadataTokens.MethodDefinitionHandle((int)rowNo);
methods[row - startRow] = (kind, new MethodDefinition(module, handle));
}
return methods.ToImmutableArray();
}
*/
}
}

Write Preview
Loading…
Cancel
Save