/// <inheritdoc /> public GenericInstanceMethodSignature ImportGenericInstanceMethodSignature(GenericInstanceMethodSignature signature) { return(new GenericInstanceMethodSignature(signature.GenericArguments.Select(ImportTypeSignature)) { Attributes = signature.Attributes, }); }
public MethodSpecification(IMethodDefOrRef method, GenericInstanceMethodSignature signature) : base(new MetadataToken(MetadataTokenType.MethodSpec)) { _method = new LazyValue <IMethodDefOrRef>(method); _signature = new LazyValue <GenericInstanceMethodSignature>(signature); CustomAttributes = new CustomAttributeCollection(this); }
/// <inheritdoc /> protected override GenericInstanceMethodSignature GetSignature() { var reader = _parentModule.DotNetDirectory.Metadata .GetStream <BlobStream>() .GetBlobReaderByIndex(_row.Instantiation); return(GenericInstanceMethodSignature.FromReader(_parentModule, reader)); }
public void ResolveTypeGenericParameterWithOnlyMethodShouldThrow() { var genericInstance = new GenericInstanceMethodSignature(); genericInstance.TypeArguments.Add(_importer.ImportTypeSignature(typeof(string))); var context = new GenericContext(null, genericInstance); var parameter = new GenericParameterSignature(GenericParameterType.Type, 0); Assert.Throws <ArgumentOutOfRangeException>(() => context.GetTypeArgument(parameter)); }
public void ResolveMethodGenericParameterWithMethod() { var genericInstance = new GenericInstanceMethodSignature(); genericInstance.TypeArguments.Add(_importer.ImportTypeSignature(typeof(string))); var context = new GenericContext(null, genericInstance); var parameter = new GenericParameterSignature(GenericParameterType.Method, 0); Assert.Equal("System.String", context.GetTypeArgument(parameter).FullName); }
public bool Equals(GenericInstanceMethodSignature signature1, GenericInstanceMethodSignature signature2) { if (signature1 == null && signature2 == null) { return(true); } if (signature1 == null || signature2 == null) { return(false); } return(signature1.Attributes == signature2.Attributes && EqualsManyTypes(signature1.GenericArguments, signature2.GenericArguments)); }
internal MethodSpecification(MetadataHeader header, MetadataToken token, MetadataRow <uint, uint> row) : base(header, token, row) { var tableStream = header.GetStream <TableStream>(); _method = new LazyValue <IMethodDefOrRef>(() => { var methodToken = tableStream.GetIndexEncoder(CodedIndex.MethodDefOrRef).DecodeIndex(row.Column1); return(methodToken.Rid != 0 ? (IMethodDefOrRef)tableStream.ResolveMember(methodToken) : null); }); _signature = new LazyValue <GenericInstanceMethodSignature>(() => GenericInstanceMethodSignature.FromReader(header, header.GetStream <BlobStream>().CreateBlobReader(row.Column2))); }
public void ResolveMethodGenericParameterWithTypeAndMethod() { var genericType = new GenericInstanceTypeSignature(_importer.ImportType(typeof(List <>)), false); genericType.TypeArguments.Add(_importer.ImportTypeSignature(typeof(string))); var genericMethod = new GenericInstanceMethodSignature(); genericMethod.TypeArguments.Add(_importer.ImportTypeSignature(typeof(int))); var context = new GenericContext(genericType, genericMethod); var parameter = new GenericParameterSignature(GenericParameterType.Method, 0); Assert.Equal("System.Int32", context.GetTypeArgument(parameter).FullName); }
internal MethodSpecification(MetadataImage image, MetadataRow <uint, uint> row) : base(row.MetadataToken) { _image = image; _method = new LazyValue <IMethodDefOrRef>(() => { var encoder = image.Header.GetStream <TableStream>().GetIndexEncoder(CodedIndex.MethodDefOrRef); var methodToken = encoder.DecodeIndex(row.Column1); return(image.TryResolveMember(methodToken, out var member) ? (IMethodDefOrRef)member : null); }); _signature = new LazyValue <GenericInstanceMethodSignature>(() => GenericInstanceMethodSignature.FromReader(image, image.Header.GetStream <BlobStream>().CreateBlobReader(row.Column2))); CustomAttributes = new CustomAttributeCollection(this); }
private CilInstruction CloneInstruction(MemberCloneContext context, CilMethodBody clonedBody, CilInstruction instruction) { var clonedInstruction = new CilInstruction(instruction.Offset, instruction.OpCode); switch (instruction.OpCode.OperandType) { case CilOperandType.InlineBrTarget: case CilOperandType.ShortInlineBrTarget: case CilOperandType.InlineSwitch: // Fix up later when all instructions are added. clonedInstruction.Operand = instruction.Operand; break; case CilOperandType.InlineI: case CilOperandType.InlineI8: case CilOperandType.InlineNone: case CilOperandType.InlineR: case CilOperandType.InlineString: case CilOperandType.ShortInlineI: case CilOperandType.ShortInlineR: clonedInstruction.Operand = instruction.Operand; break; case CilOperandType.InlineField: clonedInstruction.Operand = context.Importer.ImportField((IFieldDescriptor)instruction.Operand); break; case CilOperandType.InlineMethod: clonedInstruction.Operand = context.Importer.ImportMethod((IMethodDescriptor)instruction.Operand); break; case CilOperandType.InlineSig: if (instruction.Operand is StandAloneSignature standalone) { instruction.Operand = new StandAloneSignature(standalone.Signature switch { MethodSignature signature => context.Importer.ImportMethodSignature(signature), GenericInstanceMethodSignature signature => context.Importer.ImportGenericInstanceMethodSignature(signature), _ => throw new NotImplementedException() }); }
/// <summary> /// Creates a new reference to a generic instantiation of a method. /// </summary> /// <param name="method">The method to instantiate.</param> /// <param name="signature">The instantiation signature.</param> public MethodSpecification(IMethodDefOrRef method, GenericInstanceMethodSignature signature) : this(new MetadataToken(TableIndex.MethodSpec, 0)) { Method = method; Signature = signature; }