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)); }