private IReadOnlyList <IType> DecodeConstraints()
{
var metadata = module.metadata;
var gp = metadata.GetGenericParameter(handle);
var constraintHandleCollection = gp.GetConstraints();
List <IType> result = new List <IType>(constraintHandleCollection.Count + 1);
bool hasNonInterfaceConstraint = false;
foreach (var constraintHandle in constraintHandleCollection)
{
var constraint = metadata.GetGenericParameterConstraint(constraintHandle);
var ty = module.ResolveType(constraint.Type, new GenericContext(Owner), constraint.GetCustomAttributes());
result.Add(ty);
hasNonInterfaceConstraint |= (ty.Kind != TypeKind.Interface);
}
if (this.HasValueTypeConstraint)
{
result.Add(Compilation.FindType(KnownTypeCode.ValueType));
}
else if (!hasNonInterfaceConstraint)
{
result.Add(Compilation.FindType(KnownTypeCode.Object));
}
return(result);
}
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));
}
}
private IReadOnlyList <TypeConstraint> DecodeConstraints()
{
var metadata = module.metadata;
var gp = metadata.GetGenericParameter(handle);
Nullability nullableContext;
if (Owner is ITypeDefinition typeDef)
{
nullableContext = typeDef.NullableContext;
}
else if (Owner is MetadataMethod method)
{
nullableContext = method.NullableContext;
}
else
{
nullableContext = Nullability.Oblivious;
}
var constraintHandleCollection = gp.GetConstraints();
var result = new List <TypeConstraint>(constraintHandleCollection.Count + 1);
bool hasNonInterfaceConstraint = false;
foreach (var constraintHandle in constraintHandleCollection)
{
var constraint = metadata.GetGenericParameterConstraint(constraintHandle);
var attrs = constraint.GetCustomAttributes();
var ty = module.ResolveType(constraint.Type, new GenericContext(Owner), attrs, nullableContext);
if (attrs.Count == 0)
{
result.Add(new TypeConstraint(ty));
}
else
{
AttributeListBuilder b = new AttributeListBuilder(module);
b.Add(attrs, SymbolKind.Constraint);
result.Add(new TypeConstraint(ty, b.Build()));
}
hasNonInterfaceConstraint |= (ty.Kind != TypeKind.Interface);
}
if (this.HasValueTypeConstraint)
{
result.Add(new TypeConstraint(Compilation.FindType(KnownTypeCode.ValueType)));
}
else if (!hasNonInterfaceConstraint)
{
result.Add(new TypeConstraint(Compilation.FindType(KnownTypeCode.Object)));
}
return(result);
}
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;
}
}
}
public TokenSearchResult GetTypeFromReference(MetadataReader reader, TypeReferenceHandle handle, byte rawTypeKind)
{
var t = currentModule.ResolveType(handle, default);
return(GetResultFromResolvedType(t));
}
