public static ITypeParameter[] Create(MetadataModule module, ITypeDefinition copyFromOuter, IEntity owner, GenericParameterHandleCollection handles)
{
if (handles.Count == 0)
{
return(Empty <ITypeParameter> .Array);
}
var outerTps = copyFromOuter.TypeParameters;
var tps = new ITypeParameter[handles.Count];
int i = 0;
foreach (var handle in handles)
{
if (i < outerTps.Count)
{
tps[i] = outerTps[i];
}
else
{
tps[i] = Create(module, owner, i, handle);
}
i++;
}
return(tps);
}
void CollectNamespaces(IEntity entity, MetadataModule module, CodeMappingInfo mappingInfo = null)
{
if (entity == null || entity.MetadataToken.IsNil)
{
return;
}
if (mappingInfo == null)
{
mappingInfo = CSharpDecompiler.GetCodeMappingInfo(entity.ParentModule.PEFile, entity.MetadataToken);
}
switch (entity)
{
case ITypeDefinition td:
namespaces.Add(td.Namespace);
HandleAttributes(td.GetAttributes());
HandleTypeParameters(td.TypeParameters);
foreach (var baseType in td.DirectBaseTypes)
{
CollectNamespacesForTypeReference(baseType);
}
foreach (var nestedType in td.NestedTypes)
{
CollectNamespaces(nestedType, module, mappingInfo);
}
foreach (var field in td.Fields)
{
CollectNamespaces(field, module, mappingInfo);
}
foreach (var property in td.Properties)
{
CollectNamespaces(property, module, mappingInfo);
}
foreach (var @event in td.Events)
{
CollectNamespaces(@event, module, mappingInfo);
}
foreach (var method in td.Methods)
{
CollectNamespaces(method, module, mappingInfo);
}
break;
case IField field:
HandleAttributes(field.GetAttributes());
CollectNamespacesForTypeReference(field.ReturnType);
break;
case IMethod method:
HandleAttributes(method.GetAttributes());
HandleAttributes(method.GetReturnTypeAttributes());
CollectNamespacesForTypeReference(method.ReturnType);
foreach (var param in method.Parameters)
{
HandleAttributes(param.GetAttributes());
CollectNamespacesForTypeReference(param.Type);
}
HandleTypeParameters(method.TypeParameters);
var reader = module.PEFile.Reader;
var parts = mappingInfo.GetMethodParts((MethodDefinitionHandle)method.MetadataToken).ToList();
foreach (var part in parts)
{
HandleOverrides(part.GetMethodImplementations(module.metadata), module);
var methodDef = module.metadata.GetMethodDefinition(part);
if (method.HasBody)
{
MethodBodyBlock body;
try {
body = reader.GetMethodBody(methodDef.RelativeVirtualAddress);
} catch (BadImageFormatException) {
continue;
}
CollectNamespacesFromMethodBody(body, module);
}
}
break;
case IProperty property:
HandleAttributes(property.GetAttributes());
CollectNamespaces(property.Getter, module, mappingInfo);
CollectNamespaces(property.Setter, module, mappingInfo);
break;
case IEvent @event:
HandleAttributes(@event.GetAttributes());
CollectNamespaces(@event.AddAccessor, module, mappingInfo);
CollectNamespaces(@event.RemoveAccessor, module, mappingInfo);
break;
}
}
public static void CollectNamespaces(IEntity entity, MetadataModule module, HashSet <string> namespaces)
{
var collector = new RequiredNamespaceCollector(namespaces);
collector.CollectNamespaces(entity, module);
}
void CollectNamespacesFromMethodBody(MethodBodyBlock method, MetadataModule module)
{
var metadata = module.metadata;
var instructions = method.GetILReader();
if (!method.LocalSignature.IsNil)
{
ImmutableArray <IType> localSignature;
try {
localSignature = module.DecodeLocalSignature(method.LocalSignature, genericContext);
} catch (BadImageFormatException) {
// Issue #1211: ignore invalid local signatures
localSignature = ImmutableArray <IType> .Empty;
}
foreach (var type in localSignature)
{
CollectNamespacesForTypeReference(type);
}
}
foreach (var region in method.ExceptionRegions)
{
if (region.CatchType.IsNil)
{
continue;
}
IType ty;
try {
ty = module.ResolveType(region.CatchType, genericContext);
} catch (BadImageFormatException) {
continue;
}
CollectNamespacesForTypeReference(ty);
}
while (instructions.RemainingBytes > 0)
{
ILOpCode opCode;
try {
opCode = instructions.DecodeOpCode();
} catch (BadImageFormatException) {
return;
}
switch (opCode.GetOperandType())
{
case OperandType.Field:
case OperandType.Method:
case OperandType.Sig:
case OperandType.Tok:
case OperandType.Type:
var handle = MetadataTokenHelpers.EntityHandleOrNil(instructions.ReadInt32());
if (handle.IsNil)
{
break;
}
switch (handle.Kind)
{
case HandleKind.TypeDefinition:
case HandleKind.TypeReference:
case HandleKind.TypeSpecification:
IType type;
try {
type = module.ResolveType(handle, genericContext);
} catch (BadImageFormatException) {
break;
}
CollectNamespacesForTypeReference(type);
break;
case HandleKind.FieldDefinition:
case HandleKind.MethodDefinition:
case HandleKind.MethodSpecification:
case HandleKind.MemberReference:
IMember member;
try {
member = module.ResolveEntity(handle, genericContext) as IMember;
} catch (BadImageFormatException) {
break;
}
CollectNamespacesForMemberReference(member);
break;
case HandleKind.StandaloneSignature:
StandaloneSignature sig;
try {
sig = metadata.GetStandaloneSignature((StandaloneSignatureHandle)handle);
} catch (BadImageFormatException) {
break;
}
if (sig.GetKind() == StandaloneSignatureKind.Method)
{
MethodSignature <IType> methodSig;
try {
methodSig = module.DecodeMethodSignature((StandaloneSignatureHandle)handle, genericContext);
} catch (BadImageFormatException) {
break;
}
CollectNamespacesForTypeReference(methodSig.ReturnType);
foreach (var paramType in methodSig.ParameterTypes)
{
CollectNamespacesForTypeReference(paramType);
}
}
break;
}
break;
default:
try {
instructions.SkipOperand(opCode);
} catch (BadImageFormatException) {
return;
}
break;
}
}
}
void HandleOverrides(ImmutableArray <MethodImplementationHandle> immutableArray, MetadataModule module)
{
foreach (var h in immutableArray)
{
var methodImpl = module.metadata.GetMethodImplementation(h);
CollectNamespacesForTypeReference(module.ResolveType(methodImpl.Type, genericContext));
CollectNamespacesForMemberReference(module.ResolveMethod(methodImpl.MethodBody, genericContext));
CollectNamespacesForMemberReference(module.ResolveMethod(methodImpl.MethodDeclaration, genericContext));
}
}
public MetadataModuleFixture()
{
this.route = new RouteDescription("NamedDescription", "GET", "/things", ctx => true, typeof(object));
this.metadataModule = new FakeNancyMetadataModule();
}
public AttributeBuilder(MetadataModule module, KnownAttribute attributeType)
: this(module, module.GetAttributeType(attributeType))
{
}
public MetadataModuleFixture()
{
this.route = new RouteDescription("NamedDescription", "GET", "/things", ctx => true);
this.metadataModule = new FakeLegacyNancyMetadataModule();
}
public MetadataModuleFixture()
{
this.route = new RouteDescription("NamedDescription", "GET", "/things", ctx => true);
this.metadataModule = new FakeNancyMetadataModule();
}
internal static (IType returnType, IParameter[] parameters, ModifiedType returnTypeModifier) DecodeSignature(
MetadataModule module, IParameterizedMember owner,
MethodSignature <IType> signature, ParameterHandleCollection?parameterHandles,
Nullability nullableContext, TypeSystemOptions typeSystemOptions,
CustomAttributeHandleCollection?returnTypeAttributes = null)
{
var metadata = module.metadata;
int i = 0;
IParameter[] parameters = new IParameter[signature.RequiredParameterCount
+ (signature.Header.CallingConvention == SignatureCallingConvention.VarArgs ? 1 : 0)];
IType parameterType;
if (parameterHandles != null)
{
foreach (var parameterHandle in parameterHandles)
{
var par = metadata.GetParameter(parameterHandle);
if (par.SequenceNumber == 0)
{
// "parameter" holds return type attributes.
// Note: for properties, the attributes normally stored on a method's return type
// are instead stored as normal attributes on the property.
// So MetadataProperty provides a non-null value for returnTypeAttributes,
// which then should be preferred over the attributes on the accessor's parameters.
if (returnTypeAttributes == null)
{
returnTypeAttributes = par.GetCustomAttributes();
}
}
else if (i < par.SequenceNumber && par.SequenceNumber <= signature.RequiredParameterCount)
{
// "Successive rows of the Param table that are owned by the same method shall be
// ordered by increasing Sequence value - although gaps in the sequence are allowed"
Debug.Assert(par.SequenceNumber <= signature.ParameterTypes.Length);
Debug.Assert(par.SequenceNumber <= parameters.Length);
// Fill gaps in the sequence with non-metadata parameters:
while (i < par.SequenceNumber - 1)
{
parameterType = ApplyAttributeTypeVisitor.ApplyAttributesToType(
signature.ParameterTypes[i], module.Compilation, null, metadata, typeSystemOptions, nullableContext);
parameters[i] = new DefaultParameter(parameterType, name: string.Empty, owner,
referenceKind: parameterType.Kind == TypeKind.ByReference ? ReferenceKind.Ref : ReferenceKind.None);
i++;
}
parameterType = ApplyAttributeTypeVisitor.ApplyAttributesToType(
signature.ParameterTypes[i], module.Compilation,
par.GetCustomAttributes(), metadata, typeSystemOptions, nullableContext);
parameters[i] = new MetadataParameter(module, owner, parameterType, parameterHandle);
i++;
}
}
}
while (i < signature.RequiredParameterCount)
{
parameterType = ApplyAttributeTypeVisitor.ApplyAttributesToType(
signature.ParameterTypes[i], module.Compilation, null, metadata, typeSystemOptions, nullableContext);
parameters[i] = new DefaultParameter(parameterType, name: string.Empty, owner,
referenceKind: parameterType.Kind == TypeKind.ByReference ? ReferenceKind.Ref : ReferenceKind.None);
i++;
}
if (signature.Header.CallingConvention == SignatureCallingConvention.VarArgs)
{
parameters[i] = new DefaultParameter(SpecialType.ArgList, name: string.Empty, owner);
i++;
}
Debug.Assert(i == parameters.Length);
var returnType = ApplyAttributeTypeVisitor.ApplyAttributesToType(signature.ReturnType,
module.Compilation, returnTypeAttributes, metadata, typeSystemOptions, nullableContext,
isSignatureReturnType: true);
return(returnType, parameters, signature.ReturnType as ModifiedType);
}
public static void CollectAttributeNamespaces(MetadataModule module, HashSet <string> namespaces)
{
HandleAttributes(module.GetAssemblyAttributes(), namespaces);
HandleAttributes(module.GetModuleAttributes(), namespaces);
}
private static void GetAssemblyILCode(ReflectionDisassembler disassembler, string assemblyPath, MetadataModule module, ITextOutput output)
{
output.WriteLine("// " + assemblyPath);
output.WriteLine();
var peFile = module.PEFile;
var metadata = peFile.Metadata;
disassembler.WriteAssemblyReferences(metadata);
if (metadata.IsAssembly)
{
disassembler.WriteAssemblyHeader(peFile);
}
output.WriteLine();
disassembler.WriteModuleHeader(peFile);
}
private static ReflectionDisassembler CreateDisassembler(string assemblyPath, MetadataModule module, ITextOutput textOutput)
{
var dis = new ReflectionDisassembler(textOutput, CancellationToken.None)
{
DetectControlStructure = true,
ShowSequencePoints = false,
ShowMetadataTokens = true,
ExpandMemberDefinitions = true,
};
var resolver = new UniversalAssemblyResolver(assemblyPath,
throwOnError: true,
targetFramework: module.PEFile.Reader.DetectTargetFrameworkId());
dis.AssemblyResolver = resolver;
dis.DebugInfo = null;
return(dis);
}
internal МетаданныеМодуль(УзелМетаданных родитель, MetadataModule metadata) : base(родитель.Корень(), родитель, metadata.Name, metadata.FullName, metadata.Title)
{
}
internal static (IType, IParameter[]) DecodeSignature(MetadataModule module, IParameterizedMember owner, MethodSignature <IType> signature, ParameterHandleCollection?parameterHandles, Nullability nullableContext)
{
var metadata = module.metadata;
int i = 0;
CustomAttributeHandleCollection?returnTypeAttributes = null;
IParameter[] parameters = new IParameter[signature.RequiredParameterCount
+ (signature.Header.CallingConvention == SignatureCallingConvention.VarArgs ? 1 : 0)];
IType parameterType;
if (parameterHandles != null)
{
foreach (var parameterHandle in parameterHandles)
{
var par = metadata.GetParameter(parameterHandle);
if (par.SequenceNumber == 0)
{
// "parameter" holds return type attributes
returnTypeAttributes = par.GetCustomAttributes();
}
else if (par.SequenceNumber > 0 && i < signature.RequiredParameterCount)
{
// "Successive rows of the Param table that are owned by the same method shall be
// ordered by increasing Sequence value - although gaps in the sequence are allowed"
Debug.Assert(i < par.SequenceNumber);
// Fill gaps in the sequence with non-metadata parameters:
while (i < par.SequenceNumber - 1)
{
parameterType = ApplyAttributeTypeVisitor.ApplyAttributesToType(
signature.ParameterTypes[i], module.Compilation, null, metadata, module.TypeSystemOptions, nullableContext);
parameters[i] = new DefaultParameter(parameterType, name: string.Empty, owner,
referenceKind: parameterType.Kind == TypeKind.ByReference ? ReferenceKind.Ref : ReferenceKind.None);
i++;
}
parameterType = ApplyAttributeTypeVisitor.ApplyAttributesToType(
signature.ParameterTypes[i], module.Compilation,
par.GetCustomAttributes(), metadata, module.TypeSystemOptions, nullableContext);
parameters[i] = new MetadataParameter(module, owner, parameterType, parameterHandle);
i++;
}
}
}
while (i < signature.RequiredParameterCount)
{
parameterType = ApplyAttributeTypeVisitor.ApplyAttributesToType(
signature.ParameterTypes[i], module.Compilation, null, metadata, module.TypeSystemOptions, nullableContext);
parameters[i] = new DefaultParameter(parameterType, name: string.Empty, owner,
referenceKind: parameterType.Kind == TypeKind.ByReference ? ReferenceKind.Ref : ReferenceKind.None);
i++;
}
if (signature.Header.CallingConvention == SignatureCallingConvention.VarArgs)
{
parameters[i] = new DefaultParameter(SpecialType.ArgList, name: string.Empty, owner);
i++;
}
Debug.Assert(i == parameters.Length);
var returnType = ApplyAttributeTypeVisitor.ApplyAttributesToType(signature.ReturnType,
module.Compilation, returnTypeAttributes, metadata, module.TypeSystemOptions, nullableContext);
return(returnType, parameters);
}
public static bool AllowsDecimalConstants(MetadataModule module)
{
return((module.TypeSystemOptions & TypeSystemOptions.DecimalConstants) == TypeSystemOptions.DecimalConstants);
}
internal MetadataTypeDefinition(MetadataModule module, TypeDefinitionHandle handle)
{
Debug.Assert(module != null);
Debug.Assert(!handle.IsNil);
this.module = module;
this.handle = handle;
var metadata = module.metadata;
var td = metadata.GetTypeDefinition(handle);
this.attributes = td.Attributes;
this.fullTypeName = td.GetFullTypeName(metadata);
// Find DeclaringType + KnownTypeCode:
if (fullTypeName.IsNested)
{
this.DeclaringTypeDefinition = module.GetDefinition(td.GetDeclaringType());
// Create type parameters:
this.TypeParameters = MetadataTypeParameter.Create(module, this.DeclaringTypeDefinition, this, td.GetGenericParameters());
}
else
{
// Create type parameters:
this.TypeParameters = MetadataTypeParameter.Create(module, this, td.GetGenericParameters());
var topLevelTypeName = fullTypeName.TopLevelTypeName;
for (int i = 0; i < KnownTypeReference.KnownTypeCodeCount; i++)
{
var ktr = KnownTypeReference.Get((KnownTypeCode)i);
if (ktr != null && ktr.TypeName == topLevelTypeName)
{
this.KnownTypeCode = (KnownTypeCode)i;
break;
}
}
}
// Find type kind:
if ((attributes & TypeAttributes.ClassSemanticsMask) == TypeAttributes.Interface)
{
this.Kind = TypeKind.Interface;
}
else if (td.IsEnum(metadata, out var underlyingType))
{
this.Kind = TypeKind.Enum;
this.EnumUnderlyingType = module.Compilation.FindType(underlyingType.ToKnownTypeCode());
}
else if (td.IsValueType(metadata))
{
if (KnownTypeCode == KnownTypeCode.Void)
{
this.Kind = TypeKind.Void;
}
else
{
this.Kind = TypeKind.Struct;
this.IsByRefLike = td.GetCustomAttributes().HasKnownAttribute(metadata, KnownAttribute.IsByRefLike);
this.IsReadOnly = td.GetCustomAttributes().HasKnownAttribute(metadata, KnownAttribute.IsReadOnly);
}
}
else if (td.IsDelegate(metadata))
{
this.Kind = TypeKind.Delegate;
}
else
{
this.Kind = TypeKind.Class;
this.HasExtensionMethods = this.IsStatic &&
(module.TypeSystemOptions & TypeSystemOptions.ExtensionMethods) == TypeSystemOptions.ExtensionMethods &&
td.GetCustomAttributes().HasKnownAttribute(metadata, KnownAttribute.Extension);
}
}
public static bool IsDecimalConstant(MetadataModule module, CustomAttributeHandleCollection attributeHandles)
{
return(attributeHandles.HasKnownAttribute(module.metadata, KnownAttribute.DecimalConstant));
}
public AttributeListBuilder(MetadataModule module, int capacity)
{
Debug.Assert(module != null);
this.module = module;
this.attributes = new List <IAttribute>(capacity);
}
public DecompilerException(MetadataModule module, IEntity decompiledEntity, Exception innerException, string message = null)
: base((message ?? "Error decompiling " + decompiledEntity?.FullName) + Environment.NewLine, innerException)
{
this.Module = module;
this.DecompiledEntity = decompiledEntity;
}
