/// <summary> /// Emit generic method instantiation to the output string builder. /// </summary> /// <param name="methodInstHandle">Method instantiation handle</param> private void EmitMethodInstantiationName(MethodInstantiationHandle methodInstHandle) { MethodInstantiation methodInst = _metadataReader.GetMethodInstantiation(methodInstHandle); MethodSignature methodSignature; if (methodInst.Method.HandleType == HandleType.MemberReference) { MemberReferenceHandle methodRefHandle = methodInst.Method.ToMemberReferenceHandle(_metadataReader); MemberReference methodRef = methodRefHandle.GetMemberReference(_metadataReader); EmitContainingTypeAndMethodName(methodRef, out methodSignature); } else { QualifiedMethodHandle qualifiedMethodHandle = methodInst.Method.ToQualifiedMethodHandle(_metadataReader); QualifiedMethod qualifiedMethod = _metadataReader.GetQualifiedMethod(qualifiedMethodHandle); EmitContainingTypeAndMethodName(qualifiedMethod, out methodSignature); } EmitGenericArguments(methodInst.GenericTypeArguments); EmitMethodParameters(methodSignature); }
public MemberReferenceMethod(GenericContext gc, MemberReferenceHandle handle) : base(gc) { this.gc = gc; mr = cx.mdReader.GetMemberReference(handle); signature = mr.DecodeMethodSignature(new SignatureDecoder(), gc); parent = (GenericContext)cx.CreateGeneric(gc, mr.Parent); var parentMethod = parent as Method; var nameLabel = cx.GetId(mr.Name); declType = parentMethod == null ? parent as Type : parentMethod.DeclaringType; ShortId = MakeMethodId(declType, nameLabel); var typeSourceDeclaration = declType.SourceDeclaration; sourceDeclaration = typeSourceDeclaration == declType ? (Method)this : typeSourceDeclaration.LookupMethod(mr.Name, mr.Signature); }
private uint CalculateMemberRefTreatmentAndRowId(MemberReferenceHandle handle) { MemberRefTreatment treatment; // We need to rename the MemberRef for IClosable.Close as well // so that the MethodImpl for the Dispose method can be correctly shown // as IDisposable.Dispose instead of IDisposable.Close bool isIDisposable; if (ImplementsRedirectedInterface(handle, out isIDisposable) && isIDisposable) { treatment = MemberRefTreatment.Dispose; } else { treatment = MemberRefTreatment.None; } return(TreatmentAndRowId((byte)treatment, handle.RowId)); }
/// <summary> /// We want to know if a given method implements a redirected interface. /// For example, if we are given the method RemoveAt on a class "A" /// which implements the IVector interface (which is redirected /// to IList in .NET) then this method would return true. The most /// likely reason why we would want to know this is that we wish to hide /// (mark private) all methods which implement methods on a redirected /// interface. /// </summary> /// <param name="memberRef">The declaration token for the method</param> /// <param name="isIDisposable"> /// Returns true if the redirected interface is <see cref="IDisposable"/>. /// </param> /// <returns>True if the method implements a method on a redirected interface. /// False otherwise.</returns> private bool ImplementsRedirectedInterface(MemberReferenceHandle memberRef, out bool isIDisposable) { isIDisposable = false; EntityHandle parent = MemberRefTable.GetClass(memberRef); TypeReferenceHandle typeRef; if (parent.Kind == HandleKind.TypeReference) { typeRef = (TypeReferenceHandle)parent; } else if (parent.Kind == HandleKind.TypeSpecification) { BlobHandle blob = TypeSpecTable.GetSignature((TypeSpecificationHandle)parent); BlobReader sig = new BlobReader(BlobStream.GetMemoryBlock(blob)); if (sig.Length < 2 || sig.ReadByte() != (byte)CorElementType.ELEMENT_TYPE_GENERICINST || sig.ReadByte() != (byte)CorElementType.ELEMENT_TYPE_CLASS) { return(false); } EntityHandle token = sig.ReadTypeHandle(); if (token.Kind != HandleKind.TypeReference) { return(false); } typeRef = (TypeReferenceHandle)token; } else { return(false); } return(GetProjectionIndexForTypeReference(typeRef, out isIDisposable) >= 0); }
internal Symbol FindMember(MemberReferenceHandle memberRef, bool methodsOnly) { try { string memberName = Module.GetMemberRefNameOrThrow(memberRef); BlobHandle signatureHandle = Module.GetSignatureOrThrow(memberRef); SignatureHeader signatureHeader; BlobReader signaturePointer = this.DecodeSignatureHeaderOrThrow(signatureHandle, out signatureHeader); switch (signatureHeader.RawValue & SignatureHeader.CallingConventionOrKindMask) { case (byte)SignatureCallingConvention.Default: case (byte)SignatureCallingConvention.VarArgs: int typeParamCount; ParamInfo <TypeSymbol>[] targetParamInfo = this.DecodeSignatureParametersOrThrow(ref signaturePointer, signatureHeader, out typeParamCount); return(FindMethodBySignature(_containingType, memberName, signatureHeader, typeParamCount, targetParamInfo)); case (byte)SignatureKind.Field: if (methodsOnly) { // skip: return(null); } ImmutableArray <ModifierInfo <TypeSymbol> > customModifiers; TypeSymbol type = this.DecodeFieldSignature(ref signaturePointer, out customModifiers); return(FindFieldBySignature(_containingType, memberName, customModifiers, type)); default: // error: unexpected calling convention return(null); } } catch (BadImageFormatException) { return(null); } }
internal MemberReferenceHandle CreateConstructorForReferencedType(Type type) { var ctors = type.GetConstructors(); var typeHandle = GetOrCreateType(type); if (ctors.Length == 0) { return(default(MemberReferenceHandle)); } var handles = new MemberReferenceHandle[ctors.Length]; for (var i = 0; i < ctors.Length; i++) { var ctor = ctors[i]; if (_ctorRefHandles.TryGetValue(ctor, out var ctorDef)) { handles[i] = ctorDef; continue; } var signature = GetConstructorSignature(ctor); ctorDef = _metadataBuilder.AddMemberReference( typeHandle, GetString(ctor.Name), signature); // HACK: [vermorel] recursive insertions can happen //if(!_ctorRefHandles.ContainsKey(ctor)) _ctorRefHandles.Add(ctor, ctorDef); handles[i] = ctorDef; CreateCustomAttributes(ctorDef, ctor.GetCustomAttributesData()); } return(handles.First()); }
internal override Symbol GetSymbolForMemberRef(MemberReferenceHandle memberRef, TypeSymbol scope = null, bool methodsOnly = false) { TypeSymbol targetTypeSymbol = GetMemberRefTypeSymbol(memberRef); if (targetTypeSymbol is null) { return(null); } Debug.Assert(!targetTypeSymbol.IsTupleType); if ((object)scope != null) { Debug.Assert(scope.Kind == SymbolKind.NamedType || scope.Kind == SymbolKind.ErrorType); // We only want to consider members that are at or above "scope" in the type hierarchy. HashSet <DiagnosticInfo> useSiteDiagnostics = null; if (!TypeSymbol.Equals(scope, targetTypeSymbol, TypeCompareKind.ConsiderEverything2) && !(targetTypeSymbol.IsInterfaceType() ? scope.AllInterfacesNoUseSiteDiagnostics.IndexOf((NamedTypeSymbol)targetTypeSymbol, 0, TypeSymbol.EqualsCLRSignatureComparer) != -1 : scope.IsDerivedFrom(targetTypeSymbol, TypeCompareKind.CLRSignatureCompareOptions, useSiteDiagnostics: ref useSiteDiagnostics))) { return(null); } } if (!targetTypeSymbol.IsTupleCompatible()) { targetTypeSymbol = TupleTypeDecoder.DecodeTupleTypesIfApplicable(targetTypeSymbol, elementNames: default); } // We're going to use a special decoder that can generate usable symbols for type parameters without full context. // (We're not just using a different type - we're also changing the type context.) var memberRefDecoder = new MemberRefMetadataDecoder(moduleSymbol, targetTypeSymbol); return(memberRefDecoder.FindMember(targetTypeSymbol, memberRef, methodsOnly)); }
IField ResolveFieldReference(MemberReferenceHandle memberReferenceHandle, GenericContext context) { var memberRef = metadata.GetMemberReference(memberReferenceHandle); var declaringType = ResolveDeclaringType(memberRef.Parent, context); var declaringTypeDefinition = declaringType.GetDefinition(); string name = metadata.GetString(memberRef.Name); // field signature is for the definition, not the generic instance var signature = memberRef.DecodeFieldSignature(TypeProvider, new GenericContext(declaringTypeDefinition?.TypeParameters)); // 'f' in the predicate is also the definition, even if declaringType is a ParameterizedType var field = declaringType.GetFields(f => f.Name == name && CompareTypes(f.ReturnType, signature), GetMemberOptions.IgnoreInheritedMembers).FirstOrDefault(); if (field == null) { field = new FakeField(Compilation) { ReturnType = signature, Name = name, DeclaringType = declaringType, }; } return(field); }
internal override Symbol GetSymbolForMemberRef(MemberReferenceHandle memberRef, TypeSymbol scope = null, bool methodsOnly = false) { TypeSymbol targetTypeSymbol = GetMemberRefTypeSymbol(memberRef); // TODO: ASD: MY ADDON if (targetTypeSymbol == null) { Handle container = Module.GetContainingTypeOrThrow(memberRef); HandleType containerType = container.HandleType; if (containerType == HandleType.Method) { return(GetSymbolForILToken(container)); } } if ((object)scope != null) { Debug.Assert(scope.Kind == SymbolKind.NamedType || scope.Kind == SymbolKind.ErrorType); // We only want to consider members that are at or above "scope" in the type hierarchy. HashSet <DiagnosticInfo> useSiteDiagnostics = null; if (scope != targetTypeSymbol && !(targetTypeSymbol.IsInterfaceType() ? scope.AllInterfacesNoUseSiteDiagnostics.Contains((NamedTypeSymbol)targetTypeSymbol) : scope.IsDerivedFrom(targetTypeSymbol, ignoreDynamic: false, useSiteDiagnostics: ref useSiteDiagnostics))) { return(null); } } // We're going to use a special decoder that can generate useable symbols for type parameters without full context. // (We're not just using a different type - we're also changing the type context.) var memberRefDecoder = new MemberRefMetadataDecoder(moduleSymbol, targetTypeSymbol); return(memberRefDecoder.FindMember(targetTypeSymbol, memberRef, methodsOnly)); }
/// <summary> /// We want to know if a given method implements a redirected interface. /// For example, if we are given the method RemoveAt on a class "A" /// which implements the IVector interface (which is redirected /// to IList in .NET) then this method would return true. The most /// likely reason why we would want to know this is that we wish to hide /// (mark private) all methods which implement methods on a redirected /// interface. /// </summary> /// <param name="memberRef">The declaration token for the method</param> /// <param name="isIDisposable"> /// Returns true if the redirected interface is <see cref="IDisposable"/>. /// </param> /// <returns>True if the method implements a method on a redirected interface. /// False otherwise.</returns> private bool ImplementsRedirectedInterface(MemberReferenceHandle memberRef, out bool isIDisposable) { isIDisposable = false; EntityHandle parent = MemberRefTable.GetClass(memberRef); TypeReferenceHandle typeRef; if (parent.Kind == HandleKind.TypeReference) { typeRef = (TypeReferenceHandle)parent; } else if (parent.Kind == HandleKind.TypeSpecification) { BlobHandle blob = TypeSpecTable.GetSignature((TypeSpecificationHandle)parent); BlobReader sig = BlobStream.GetBlobReader(blob); if (sig.Length < 2 || sig.ReadByte() != (byte)CorElementType.ELEMENT_TYPE_GENERICINST || sig.ReadByte() != (byte)CorElementType.ELEMENT_TYPE_CLASS) { return false; } EntityHandle token = sig.ReadTypeHandle(); if (token.Kind != HandleKind.TypeReference) { return false; } typeRef = (TypeReferenceHandle)token; } else { return false; } return GetProjectionIndexForTypeReference(typeRef, out isIDisposable) >= 0; }
internal EntityHandle GetClass(MemberReferenceHandle handle) { int rowOffset = (handle.RowId - 1) * this.RowSize; return MemberRefParentTag.ConvertToHandle(this.Block.PeekTaggedReference(rowOffset + _ClassOffset, _IsMemberRefParentRefSizeSmall)); }
internal BlobHandle GetSignature(MemberReferenceHandle handle) { int rowOffset = (handle.RowId - 1) * this.RowSize; return BlobHandle.FromOffset(this.Block.PeekHeapReference(rowOffset + _SignatureOffset, _IsBlobHeapRefSizeSmall)); }
public Mapping<MemberReferenceHandle> MapMemberReference(MemberReferenceHandle handle) { return _memberReferences.GetOrAdd(handle, MapMemberReferenceImpl); }
private Mapping <MemberReferenceHandle> MapMemberReferenceImpl(MemberReferenceHandle handle) { throw new NotImplementedException(); }
MethodDesc IR2RSignatureTypeProvider <TypeDesc, MethodDesc, R2RSigProviderContext> .GetMethodFromMemberRef(MetadataReader reader, MemberReferenceHandle handle, TypeDesc owningTypeOverride) { var ecmaModule = (EcmaModule)_tsc.GetModuleForSimpleName(reader.GetString(reader.GetAssemblyDefinition().Name)); var method = (MethodDesc)ecmaModule.GetObject(handle, NotFoundBehavior.ReturnNull); if (method == null) { return(null); } if (owningTypeOverride != null) { return(_tsc.GetMethodForInstantiatedType(method.GetTypicalMethodDefinition(), (InstantiatedType)owningTypeOverride)); } return(method); }
public void MethodImplEntry() { var text = @" public class A { ~A() { } } "; CompileAndVerify( text, assemblyValidator: (assembly) => { var peFileReader = assembly.GetMetadataReader(); // Find the handle and row for A. var pairA = peFileReader.TypeDefinitions .AsEnumerable() .Select( handle => new { handle = handle, row = peFileReader.GetTypeDefinition(handle) } ) .Single( pair => peFileReader.GetString(pair.row.Name) == "A" && string.IsNullOrEmpty(peFileReader.GetString(pair.row.Namespace)) ); TypeDefinitionHandle handleA = pairA.handle; TypeDefinition typeA = pairA.row; // Find the handle for A's destructor. MethodDefinitionHandle handleDestructorA = typeA .GetMethods() .AsEnumerable() .Single( handle => peFileReader.GetString( peFileReader.GetMethodDefinition(handle).Name ) == WellKnownMemberNames.DestructorName ); // Find the handle for System.Object. TypeReferenceHandle handleObject = peFileReader.TypeReferences .AsEnumerable() .Select( handle => new { handle = handle, row = peFileReader.GetTypeReference(handle) } ) .Single( pair => peFileReader.GetString(pair.row.Name) == "Object" && peFileReader.GetString(pair.row.Namespace) == "System" ).handle; // Find the handle for System.Object's destructor. MemberReferenceHandle handleDestructorObject = peFileReader.MemberReferences .AsEnumerable() .Select( handle => new { handle = handle, row = peFileReader.GetMemberReference(handle) } ) .Single( pair => pair.row.Parent == (EntityHandle)handleObject && peFileReader.GetString(pair.row.Name) == WellKnownMemberNames.DestructorName ).handle; // Find the MethodImpl row for A. MethodImplementation methodImpl = typeA .GetMethodImplementations() .AsEnumerable() .Select(handle => peFileReader.GetMethodImplementation(handle)) .Single(); // The Class column should point to A. Assert.Equal(handleA, methodImpl.Type); // The MethodDeclaration column should point to System.Object.Finalize. Assert.Equal( (EntityHandle)handleDestructorObject, methodImpl.MethodDeclaration ); // The MethodDeclarationColumn should point to A's destructor. Assert.Equal((EntityHandle)handleDestructorA, methodImpl.MethodBody); } ); }
/// <summary> /// We want to know if a given method implements a redirected interface. /// For example, if we are given the method RemoveAt on a class "A" /// which implements the IVector interface (which is redirected /// to IList in .NET) then this method would return true. The most /// likely reason why we would want to know this is that we wish to hide /// (mark private) all methods which implement methods on a redirected /// interface. /// </summary> /// <param name="memberRef">The declaration token for the method</param> /// <param name="isIDisposable"> /// Returns true if the redirected interface is <see cref="IDisposable"/>. /// </param> /// <returns>True if the method implements a method on a redirected interface. /// False otherwise.</returns> private bool ImplementsRedirectedInterface(MemberReferenceHandle memberRef, out bool isIDisposable) { isIDisposable = false; MetadataToken parent = peFileReader.GetMemberReference((MemberReferenceHandle)memberRef).Parent; TypeReferenceHandle typeRef; if (parent.HandleType == HandleType.TypeReference) { typeRef = (TypeReferenceHandle)parent; } else if (parent.HandleType == HandleType.TypeSpecification) { BlobHandle blob = peFileReader.GetTypeSpecification((TypeSpecificationHandle)parent); MemoryBlock sigBlock = peFileReader.BlobStream.GetMemoryBlockAt(blob); if (sigBlock.Length < 2) return false; MemoryReader sig = new MemoryReader(sigBlock); if (sig.ReadByte() != (byte)CorElementType.ELEMENT_TYPE_GENERICINST || sig.ReadByte() != (byte)CorElementType.ELEMENT_TYPE_CLASS) { return false; } MetadataToken token = SignatureHelpers.DecodeToken(ref sig); if (token.HandleType != HandleType.TypeReference) return false; typeRef = (TypeReferenceHandle)token; } else { return false; } TypeReference reference = peFileReader.GetTypeReference(typeRef); if (reference.Namespace.IsNil) { return false; } string name = peFileReader.StringStream[reference.Name]; string @namespace = peFileReader.StringStream[reference.Namespace]; return WinRTProjectedTypes.IsWinRTTypeReference(name, @namespace, out isIDisposable); }
public override string GetMemberRefName(MemberReferenceHandle memberRef) { string name; // We need to rename the MemberRef for IClosable.Close as well // so that the MethodImpl for the Dispose method can be correctly shown // as IDisposable.Dispose instead of IDisposable.Close bool isIDisposable; if (ImplementsRedirectedInterface(memberRef, out isIDisposable) && isIDisposable) { name = "Dispose"; } else { name = base.GetMemberRefName(memberRef); } return name; }
internal Handle GetClass(MemberReferenceHandle handle) { int rowOffset = (int)(handle.RowId - 1) * this.RowSize; return MemberRefParentTag.ConvertToToken(this.Block.PeekTaggedReference(rowOffset + this.ClassOffset, this.IsMemberRefParentRefSizeSmall)); }
private Mapping<MemberReferenceHandle> MapMemberReferenceImpl(MemberReferenceHandle handle) { throw new NotImplementedException(); }
private MemberReferenceHandle Import(MemberReferenceHandle srcHandle) => ImportEntity(srcHandle, _memberReferenceCache, _reader.GetMemberReference, src => _builder.AddMemberReference(Import(src.Parent), ImportValue(src.Name), ImportSignatureWithHeader(src.Signature)), _reader.ToString, IsNil);
public Mapping <MemberReferenceHandle> MapMemberReference(MemberReferenceHandle handle) { return(_memberReferences.GetOrAdd(handle, MapMemberReferenceImpl)); }
public static string ToString(this MetadataReader reader, MemberReferenceHandle x) => reader.ToString(reader.GetMemberReference(x));
private NetType GetTypeFromMemberReferenceHandle(MemberReferenceHandle handle) { var memberReference = Reader.GetMemberReference(handle); return(GetTypeFromEntityHandle((TypeReferenceHandle)memberReference.Parent)); }
/// <summary> /// Encodes <code>call</code> instruction and its operand. /// </summary> public void Call(MemberReferenceHandle methodHandle) { OpCode(ILOpCode.Call); Token(methodHandle); }
private static MethodDefinitionHandle EmitMethod(string assemblyName, MetadataBuilder metadata, BlobBuilder ilBuilder, string name, Func <MetadataBuilder, BlobBuilder> signatureCallback, string[] paramNames) { BlobBuilder methodSignature = signatureCallback(metadata); // Create module and assembly metadata.AddModule( 0, metadata.GetOrAddString(assemblyName + ".dll"), metadata.GetOrAddGuid(s_guid), default(GuidHandle), default(GuidHandle)); metadata.AddAssembly( metadata.GetOrAddString(assemblyName), version: new Version(1, 0, 0, 0), culture: default(StringHandle), publicKey: default(BlobHandle), flags: 0, hashAlgorithm: AssemblyHashAlgorithm.None); // Create references to System.Object and System.Console types. AssemblyReferenceHandle mscorlibAssemblyRef = metadata.AddAssemblyReference( name: metadata.GetOrAddString("System.Runtime"), version: new Version(4, 0, 0, 0), culture: default(StringHandle), publicKeyOrToken: default(BlobHandle), flags: default(AssemblyFlags), hashValue: default(BlobHandle)); TypeReferenceHandle systemObjectTypeRef = metadata.AddTypeReference( mscorlibAssemblyRef, metadata.GetOrAddString("System"), metadata.GetOrAddString("Object")); // Get reference to Object's constructor. var parameterlessCtorSignature = new BlobBuilder(); new BlobEncoder(parameterlessCtorSignature). MethodSignature(isInstanceMethod: true). Parameters(0, returnType => returnType.Void(), parameters => { }); BlobHandle parameterlessCtorBlobIndex = metadata.GetOrAddBlob(parameterlessCtorSignature); MemberReferenceHandle objectCtorMemberRef = metadata.AddMemberReference( systemObjectTypeRef, metadata.GetOrAddString(".ctor"), parameterlessCtorBlobIndex); var methodBodyStream = new MethodBodyStreamEncoder(ilBuilder); var codeBuilder = new BlobBuilder(); InstructionEncoder il; // Emit IL for Program::.ctor il = new InstructionEncoder(codeBuilder); // ldarg.0 il.LoadArgument(0); // call instance void [mscorlib]System.Object::.ctor() il.Call(objectCtorMemberRef); // ret il.OpCode(ILOpCode.Ret); int ctorBodyOffset = methodBodyStream.AddMethodBody(il); codeBuilder.Clear(); // Emit IL for a method il = new InstructionEncoder(codeBuilder); il.OpCode(ILOpCode.Ldnull); il.OpCode(ILOpCode.Throw); int methodBodyOffset = methodBodyStream.AddMethodBody(il); codeBuilder.Clear(); // Create parameters for a method definition int nextParameterIndex = 1; ParameterHandle pFirst = default(ParameterHandle); for (int i = 0; i < paramNames.Length; i++) { ParameterHandle p = metadata.AddParameter( ParameterAttributes.None, metadata.GetOrAddString(paramNames[i]), i + 1); nextParameterIndex++; if (i == 0) { pFirst = p; } } // Create method definition MethodDefinitionHandle methodDef = metadata.AddMethodDefinition( MethodAttributes.Public | MethodAttributes.Static | MethodAttributes.HideBySig, MethodImplAttributes.IL, metadata.GetOrAddString(name), metadata.GetOrAddBlob(methodSignature), methodBodyOffset, parameterList: pFirst); // Create method definition for Program::.ctor MethodDefinitionHandle ctorDef = metadata.AddMethodDefinition( MethodAttributes.Public | MethodAttributes.HideBySig | MethodAttributes.SpecialName | MethodAttributes.RTSpecialName, MethodImplAttributes.IL, metadata.GetOrAddString(".ctor"), parameterlessCtorBlobIndex, ctorBodyOffset, parameterList: MetadataTokens.ParameterHandle(nextParameterIndex)); // Create type definition for the special <Module> type that holds global functions metadata.AddTypeDefinition( default(TypeAttributes), default(StringHandle), metadata.GetOrAddString("<Module>"), baseType: default(EntityHandle), fieldList: MetadataTokens.FieldDefinitionHandle(1), methodList: MetadataTokens.MethodDefinitionHandle(1)); // Create type definition for ConsoleApplication.Program metadata.AddTypeDefinition( TypeAttributes.Class | TypeAttributes.Public | TypeAttributes.AutoLayout | TypeAttributes.BeforeFieldInit, metadata.GetOrAddString(assemblyName), metadata.GetOrAddString("Program"), baseType: systemObjectTypeRef, fieldList: MetadataTokens.FieldDefinitionHandle(1), methodList: methodDef); return(methodDef); }
private void WriteResolvedToken(MemberReferenceHandle memberRefHandle) { var memberRef = metadataReader.GetMemberReference(memberRefHandle); // type name string fullName = GetFullTypeName(metadataReader, memberRef.Parent); if (fullName != null) { writer.WriteAttributeString("declaringType", fullName); } // method name writer.WriteAttributeString("methodName", metadataReader.GetString(memberRef.Name)); }
/// <summary> /// Encodes <code>call</code> instruction and its operand. /// </summary> public void Call(MemberReferenceHandle methodHandle) { OpCode(ILOpCode.Call); Token(methodHandle); }
public static MemberReference GetMemberReference(this MemberReferenceHandle handle, MetadataReader reader) => reader.GetMemberReference(handle);
internal StringHandle GetName(MemberReferenceHandle handle) { int rowOffset = (handle.RowId - 1) * this.RowSize; return StringHandle.FromOffset(this.Block.PeekHeapReference(rowOffset + _NameOffset, _IsStringHeapRefSizeSmall)); }
/// <summary> /// Search through the members of a given type symbol to find the method that matches a particular /// signature. /// </summary> /// <param name="targetTypeSymbol">Type containing the desired method symbol.</param> /// <param name="memberRef">A MemberRef handle that can be used to obtain the name and signature of the method</param> /// <param name="methodsOnly">True to only return a method.</param> /// <returns>The matching method symbol, or null if the inputs do not correspond to a valid method.</returns> internal Symbol FindMember(TypeSymbol targetTypeSymbol, MemberReferenceHandle memberRef, bool methodsOnly) { if ((object)targetTypeSymbol == null) { return null; } try { string memberName = Module.GetMemberRefNameOrThrow(memberRef); BlobHandle signatureHandle = Module.GetSignatureOrThrow(memberRef); SignatureHeader signatureHeader; BlobReader signaturePointer = this.DecodeSignatureHeaderOrThrow(signatureHandle, out signatureHeader); switch (signatureHeader.RawValue & SignatureHeader.CallingConventionOrKindMask) { case (byte)SignatureCallingConvention.Default: case (byte)SignatureCallingConvention.VarArgs: int typeParamCount; ParamInfo<TypeSymbol>[] targetParamInfo = this.DecodeSignatureParametersOrThrow(ref signaturePointer, signatureHeader, out typeParamCount); return FindMethodBySignature(targetTypeSymbol, memberName, signatureHeader, typeParamCount, targetParamInfo); case (byte)SignatureKind.Field: if (methodsOnly) { // skip: return null; } ImmutableArray<ModifierInfo<TypeSymbol>> customModifiers; bool isVolatile; TypeSymbol type = this.DecodeFieldSignature(ref signaturePointer, out isVolatile, out customModifiers); return FindFieldBySignature(targetTypeSymbol, memberName, customModifiers, type); default: // error: unexpected calling convention return null; } } catch (BadImageFormatException) { return null; } }
private Object ResolveMemberReference(MemberReferenceHandle handle) { MemberReference memberReference = _metadataReader.GetMemberReference(handle); Object parent = GetObject(memberReference.Parent, NotFoundBehavior.ReturnResolutionFailure); if (parent is ResolutionFailure) { return(parent); } TypeDesc parentTypeDesc = parent as TypeDesc; if (parentTypeDesc != null) { BlobReader signatureReader = _metadataReader.GetBlobReader(memberReference.Signature); EcmaSignatureParser parser = new EcmaSignatureParser(this, signatureReader, NotFoundBehavior.ReturnResolutionFailure); string name = _metadataReader.GetString(memberReference.Name); if (parser.IsFieldSignature) { FieldDesc field = parentTypeDesc.GetField(name); if (field != null) { return(field); } return(ResolutionFailure.GetMissingFieldFailure(parentTypeDesc, name)); } else { MethodSignature sig = parser.ParseMethodSignature(); if (sig == null) { return(parser.ResolutionFailure); } TypeDesc typeDescToInspect = parentTypeDesc; Instantiation substitution = default(Instantiation); // Try to resolve the name and signature in the current type, or any of the base types. do { MethodDesc method = typeDescToInspect.GetMethod(name, sig, substitution); if (method != null) { // If this resolved to one of the base types, make sure it's not a constructor. // Instance constructors are not inherited. if (typeDescToInspect != parentTypeDesc && method.IsConstructor) { break; } return(method); } var baseType = typeDescToInspect.BaseType; if (baseType != null) { if (!baseType.HasInstantiation) { substitution = default(Instantiation); } else { // If the base type is generic, any signature match for methods on the base type with the generic details from // the deriving type Instantiation newSubstitution = typeDescToInspect.GetTypeDefinition().BaseType.Instantiation; if (!substitution.IsNull) { TypeDesc[] newSubstitutionTypes = new TypeDesc[newSubstitution.Length]; for (int i = 0; i < newSubstitution.Length; i++) { newSubstitutionTypes[i] = newSubstitution[i].InstantiateSignature(substitution, default(Instantiation)); } newSubstitution = new Instantiation(newSubstitutionTypes); } substitution = newSubstitution; } } typeDescToInspect = baseType; } while (typeDescToInspect != null); return(ResolutionFailure.GetMissingMethodFailure(parentTypeDesc, name, sig)); } } else if (parent is MethodDesc) { ThrowHelper.ThrowInvalidProgramException(ExceptionStringID.InvalidProgramVararg, (MethodDesc)parent); } else if (parent is ModuleDesc) { throw new NotImplementedException("MemberRef to a global function or variable."); } ThrowHelper.ThrowBadImageFormatException(); return(null); }
public MemberReference GetMemberReference(MemberReferenceHandle handle) { // PERF: This code pattern is JIT friendly and results in very efficient code. return new MemberReference(this, GetMemberRefTreatmentAndRowId(handle)); }
private Object ResolveMemberReference(MemberReferenceHandle handle) { MemberReference memberReference = _metadataReader.GetMemberReference(handle); Object parent = GetObject(memberReference.Parent); TypeDesc parentTypeDesc = parent as TypeDesc; if (parentTypeDesc != null) { BlobReader signatureReader = _metadataReader.GetBlobReader(memberReference.Signature); EcmaSignatureParser parser = new EcmaSignatureParser(this, signatureReader); string name = _metadataReader.GetString(memberReference.Name); if (parser.IsFieldSignature) { FieldDesc field = parentTypeDesc.GetField(name); if (field != null) { return(field); } throw new TypeSystemException.MissingFieldException(parentTypeDesc, name); } else { MethodSignature sig = parser.ParseMethodSignature(); TypeDesc typeDescToInspect = parentTypeDesc; // Try to resolve the name and signature in the current type, or any of the base types. do { // TODO: handle substitutions MethodDesc method = typeDescToInspect.GetMethod(name, sig); if (method != null) { // If this resolved to one of the base types, make sure it's not a constructor. // Instance constructors are not inherited. if (typeDescToInspect != parentTypeDesc && method.IsConstructor) { break; } return(method); } typeDescToInspect = typeDescToInspect.BaseType; } while (typeDescToInspect != null); throw new TypeSystemException.MissingMethodException(parentTypeDesc, name, sig); } } else if (parent is MethodDesc) { throw new TypeSystemException.InvalidProgramException(ExceptionStringID.InvalidProgramVararg, (MethodDesc)parent); } else if (parent is ModuleDesc) { throw new NotImplementedException("MemberRef to a global function or variable."); } throw new BadImageFormatException(); }
public void IsNil() { Assert.False(ModuleDefinitionHandle.FromRowId(1).IsNil); Assert.False(AssemblyDefinitionHandle.FromRowId(1).IsNil); Assert.False(InterfaceImplementationHandle.FromRowId(1).IsNil); Assert.False(MethodDefinitionHandle.FromRowId(1).IsNil); Assert.False(MethodSpecificationHandle.FromRowId(1).IsNil); Assert.False(TypeDefinitionHandle.FromRowId(1).IsNil); Assert.False(ExportedTypeHandle.FromRowId(1).IsNil); Assert.False(TypeReferenceHandle.FromRowId(1).IsNil); Assert.False(TypeSpecificationHandle.FromRowId(1).IsNil); Assert.False(MemberReferenceHandle.FromRowId(1).IsNil); Assert.False(FieldDefinitionHandle.FromRowId(1).IsNil); Assert.False(EventDefinitionHandle.FromRowId(1).IsNil); Assert.False(PropertyDefinitionHandle.FromRowId(1).IsNil); Assert.False(StandaloneSignatureHandle.FromRowId(1).IsNil); Assert.False(MemberReferenceHandle.FromRowId(1).IsNil); Assert.False(FieldDefinitionHandle.FromRowId(1).IsNil); Assert.False(EventDefinitionHandle.FromRowId(1).IsNil); Assert.False(PropertyDefinitionHandle.FromRowId(1).IsNil); Assert.False(ParameterHandle.FromRowId(1).IsNil); Assert.False(GenericParameterHandle.FromRowId(1).IsNil); Assert.False(GenericParameterConstraintHandle.FromRowId(1).IsNil); Assert.False(ModuleReferenceHandle.FromRowId(1).IsNil); Assert.False(CustomAttributeHandle.FromRowId(1).IsNil); Assert.False(DeclarativeSecurityAttributeHandle.FromRowId(1).IsNil); Assert.False(ManifestResourceHandle.FromRowId(1).IsNil); Assert.False(ConstantHandle.FromRowId(1).IsNil); Assert.False(ManifestResourceHandle.FromRowId(1).IsNil); Assert.False(AssemblyFileHandle.FromRowId(1).IsNil); Assert.False(MethodImplementationHandle.FromRowId(1).IsNil); Assert.False(AssemblyReferenceHandle.FromRowId(1).IsNil); Assert.False(((EntityHandle)ModuleDefinitionHandle.FromRowId(1)).IsNil); Assert.False(((EntityHandle)AssemblyDefinitionHandle.FromRowId(1)).IsNil); Assert.False(((EntityHandle)InterfaceImplementationHandle.FromRowId(1)).IsNil); Assert.False(((EntityHandle)MethodDefinitionHandle.FromRowId(1)).IsNil); Assert.False(((EntityHandle)MethodSpecificationHandle.FromRowId(1)).IsNil); Assert.False(((EntityHandle)TypeDefinitionHandle.FromRowId(1)).IsNil); Assert.False(((EntityHandle)ExportedTypeHandle.FromRowId(1)).IsNil); Assert.False(((EntityHandle)TypeReferenceHandle.FromRowId(1)).IsNil); Assert.False(((EntityHandle)TypeSpecificationHandle.FromRowId(1)).IsNil); Assert.False(((EntityHandle)MemberReferenceHandle.FromRowId(1)).IsNil); Assert.False(((EntityHandle)FieldDefinitionHandle.FromRowId(1)).IsNil); Assert.False(((EntityHandle)EventDefinitionHandle.FromRowId(1)).IsNil); Assert.False(((EntityHandle)PropertyDefinitionHandle.FromRowId(1)).IsNil); Assert.False(((EntityHandle)StandaloneSignatureHandle.FromRowId(1)).IsNil); Assert.False(((EntityHandle)MemberReferenceHandle.FromRowId(1)).IsNil); Assert.False(((EntityHandle)FieldDefinitionHandle.FromRowId(1)).IsNil); Assert.False(((EntityHandle)EventDefinitionHandle.FromRowId(1)).IsNil); Assert.False(((EntityHandle)PropertyDefinitionHandle.FromRowId(1)).IsNil); Assert.False(((EntityHandle)ParameterHandle.FromRowId(1)).IsNil); Assert.False(((EntityHandle)GenericParameterHandle.FromRowId(1)).IsNil); Assert.False(((EntityHandle)GenericParameterConstraintHandle.FromRowId(1)).IsNil); Assert.False(((EntityHandle)ModuleReferenceHandle.FromRowId(1)).IsNil); Assert.False(((EntityHandle)CustomAttributeHandle.FromRowId(1)).IsNil); Assert.False(((EntityHandle)DeclarativeSecurityAttributeHandle.FromRowId(1)).IsNil); Assert.False(((EntityHandle)ManifestResourceHandle.FromRowId(1)).IsNil); Assert.False(((EntityHandle)ConstantHandle.FromRowId(1)).IsNil); Assert.False(((EntityHandle)ManifestResourceHandle.FromRowId(1)).IsNil); Assert.False(((EntityHandle)AssemblyFileHandle.FromRowId(1)).IsNil); Assert.False(((EntityHandle)MethodImplementationHandle.FromRowId(1)).IsNil); Assert.False(((EntityHandle)AssemblyReferenceHandle.FromRowId(1)).IsNil); Assert.False(StringHandle.FromOffset(1).IsNil); Assert.False(BlobHandle.FromOffset(1).IsNil); Assert.False(UserStringHandle.FromOffset(1).IsNil); Assert.False(GuidHandle.FromIndex(1).IsNil); Assert.False(((Handle)StringHandle.FromOffset(1)).IsNil); Assert.False(((Handle)BlobHandle.FromOffset(1)).IsNil); Assert.False(((Handle)UserStringHandle.FromOffset(1)).IsNil); Assert.False(((Handle)GuidHandle.FromIndex(1)).IsNil); Assert.True(ModuleDefinitionHandle.FromRowId(0).IsNil); Assert.True(AssemblyDefinitionHandle.FromRowId(0).IsNil); Assert.True(InterfaceImplementationHandle.FromRowId(0).IsNil); Assert.True(MethodDefinitionHandle.FromRowId(0).IsNil); Assert.True(MethodSpecificationHandle.FromRowId(0).IsNil); Assert.True(TypeDefinitionHandle.FromRowId(0).IsNil); Assert.True(ExportedTypeHandle.FromRowId(0).IsNil); Assert.True(TypeReferenceHandle.FromRowId(0).IsNil); Assert.True(TypeSpecificationHandle.FromRowId(0).IsNil); Assert.True(MemberReferenceHandle.FromRowId(0).IsNil); Assert.True(FieldDefinitionHandle.FromRowId(0).IsNil); Assert.True(EventDefinitionHandle.FromRowId(0).IsNil); Assert.True(PropertyDefinitionHandle.FromRowId(0).IsNil); Assert.True(StandaloneSignatureHandle.FromRowId(0).IsNil); Assert.True(MemberReferenceHandle.FromRowId(0).IsNil); Assert.True(FieldDefinitionHandle.FromRowId(0).IsNil); Assert.True(EventDefinitionHandle.FromRowId(0).IsNil); Assert.True(PropertyDefinitionHandle.FromRowId(0).IsNil); Assert.True(ParameterHandle.FromRowId(0).IsNil); Assert.True(GenericParameterHandle.FromRowId(0).IsNil); Assert.True(GenericParameterConstraintHandle.FromRowId(0).IsNil); Assert.True(ModuleReferenceHandle.FromRowId(0).IsNil); Assert.True(CustomAttributeHandle.FromRowId(0).IsNil); Assert.True(DeclarativeSecurityAttributeHandle.FromRowId(0).IsNil); Assert.True(ManifestResourceHandle.FromRowId(0).IsNil); Assert.True(ConstantHandle.FromRowId(0).IsNil); Assert.True(ManifestResourceHandle.FromRowId(0).IsNil); Assert.True(AssemblyFileHandle.FromRowId(0).IsNil); Assert.True(MethodImplementationHandle.FromRowId(0).IsNil); Assert.True(AssemblyReferenceHandle.FromRowId(0).IsNil); Assert.True(((EntityHandle)ModuleDefinitionHandle.FromRowId(0)).IsNil); Assert.True(((EntityHandle)AssemblyDefinitionHandle.FromRowId(0)).IsNil); Assert.True(((EntityHandle)InterfaceImplementationHandle.FromRowId(0)).IsNil); Assert.True(((EntityHandle)MethodDefinitionHandle.FromRowId(0)).IsNil); Assert.True(((EntityHandle)MethodSpecificationHandle.FromRowId(0)).IsNil); Assert.True(((EntityHandle)TypeDefinitionHandle.FromRowId(0)).IsNil); Assert.True(((EntityHandle)ExportedTypeHandle.FromRowId(0)).IsNil); Assert.True(((EntityHandle)TypeReferenceHandle.FromRowId(0)).IsNil); Assert.True(((EntityHandle)TypeSpecificationHandle.FromRowId(0)).IsNil); Assert.True(((EntityHandle)MemberReferenceHandle.FromRowId(0)).IsNil); Assert.True(((EntityHandle)FieldDefinitionHandle.FromRowId(0)).IsNil); Assert.True(((EntityHandle)EventDefinitionHandle.FromRowId(0)).IsNil); Assert.True(((EntityHandle)PropertyDefinitionHandle.FromRowId(0)).IsNil); Assert.True(((EntityHandle)StandaloneSignatureHandle.FromRowId(0)).IsNil); Assert.True(((EntityHandle)MemberReferenceHandle.FromRowId(0)).IsNil); Assert.True(((EntityHandle)FieldDefinitionHandle.FromRowId(0)).IsNil); Assert.True(((EntityHandle)EventDefinitionHandle.FromRowId(0)).IsNil); Assert.True(((EntityHandle)PropertyDefinitionHandle.FromRowId(0)).IsNil); Assert.True(((EntityHandle)ParameterHandle.FromRowId(0)).IsNil); Assert.True(((EntityHandle)GenericParameterHandle.FromRowId(0)).IsNil); Assert.True(((EntityHandle)GenericParameterConstraintHandle.FromRowId(0)).IsNil); Assert.True(((EntityHandle)ModuleReferenceHandle.FromRowId(0)).IsNil); Assert.True(((EntityHandle)CustomAttributeHandle.FromRowId(0)).IsNil); Assert.True(((EntityHandle)DeclarativeSecurityAttributeHandle.FromRowId(0)).IsNil); Assert.True(((EntityHandle)ManifestResourceHandle.FromRowId(0)).IsNil); Assert.True(((EntityHandle)ConstantHandle.FromRowId(0)).IsNil); Assert.True(((EntityHandle)ManifestResourceHandle.FromRowId(0)).IsNil); Assert.True(((EntityHandle)AssemblyFileHandle.FromRowId(0)).IsNil); Assert.True(((EntityHandle)MethodImplementationHandle.FromRowId(0)).IsNil); Assert.True(((EntityHandle)AssemblyReferenceHandle.FromRowId(0)).IsNil); // heaps: Assert.True(StringHandle.FromOffset(0).IsNil); Assert.True(BlobHandle.FromOffset(0).IsNil); Assert.True(UserStringHandle.FromOffset(0).IsNil); Assert.True(GuidHandle.FromIndex(0).IsNil); Assert.True(((Handle)StringHandle.FromOffset(0)).IsNil); Assert.True(((Handle)BlobHandle.FromOffset(0)).IsNil); Assert.True(((Handle)UserStringHandle.FromOffset(0)).IsNil); Assert.True(((Handle)GuidHandle.FromIndex(0)).IsNil); // virtual: Assert.False(AssemblyReferenceHandle.FromVirtualIndex(0).IsNil); Assert.False(StringHandle.FromVirtualIndex(0).IsNil); Assert.False(BlobHandle.FromVirtualIndex(0, 0).IsNil); Assert.False(((Handle)AssemblyReferenceHandle.FromVirtualIndex(0)).IsNil); Assert.False(((Handle)StringHandle.FromVirtualIndex(0)).IsNil); Assert.False(((Handle)BlobHandle.FromVirtualIndex(0, 0)).IsNil); }
private uint CalculateMemberRefTreatmentAndRowId(MemberReferenceHandle handle) { MemberRefTreatment treatment; // We need to rename the MemberRef for IClosable.Close as well // so that the MethodImpl for the Dispose method can be correctly shown // as IDisposable.Dispose instead of IDisposable.Close bool isIDisposable; if (ImplementsRedirectedInterface(handle, out isIDisposable) && isIDisposable) { treatment = MemberRefTreatment.Dispose; } else { treatment = MemberRefTreatment.None; } return TreatmentAndRowId((byte)treatment, handle.RowId); }
internal StringHandle GetName(MemberReferenceHandle handle) { int rowOffset = (int)(handle.RowId - 1) * this.RowSize; return StringHandle.FromIndex(this.Block.PeekReference(rowOffset + this.NameOffset, this.IsStringHeapRefSizeSmall)); }
private static MethodDefinitionHandle EmitHelloWorld(MetadataBuilder metadata, BlobBuilder ilBuilder) { // Create module and assembly for a console application. metadata.AddModule( 0, metadata.GetOrAddString("ConsoleApplication.exe"), metadata.GetOrAddGuid(s_guid), default(GuidHandle), default(GuidHandle)); metadata.AddAssembly( metadata.GetOrAddString("ConsoleApplication"), version: new Version(1, 0, 0, 0), culture: default(StringHandle), publicKey: default(BlobHandle), flags: 0, hashAlgorithm: AssemblyHashAlgorithm.None); // Create references to System.Object and System.Console types. AssemblyReferenceHandle mscorlibAssemblyRef = metadata.AddAssemblyReference( name: metadata.GetOrAddString("mscorlib"), version: new Version(4, 0, 0, 0), culture: default(StringHandle), publicKeyOrToken: metadata.GetOrAddBlob( new byte[] { 0xB7, 0x7A, 0x5C, 0x56, 0x19, 0x34, 0xE0, 0x89 } ), flags: default(AssemblyFlags), hashValue: default(BlobHandle)); TypeReferenceHandle systemObjectTypeRef = metadata.AddTypeReference( mscorlibAssemblyRef, metadata.GetOrAddString("System"), metadata.GetOrAddString("Object")); TypeReferenceHandle systemConsoleTypeRefHandle = metadata.AddTypeReference( mscorlibAssemblyRef, metadata.GetOrAddString("System"), metadata.GetOrAddString("Console")); // Get reference to Console.WriteLine(string) method. var consoleWriteLineSignature = new BlobBuilder(); new BlobEncoder(consoleWriteLineSignature). MethodSignature(). Parameters(1, returnType => returnType.Void(), parameters => parameters.AddParameter().Type().String()); MemberReferenceHandle consoleWriteLineMemberRef = metadata.AddMemberReference( systemConsoleTypeRefHandle, metadata.GetOrAddString("WriteLine"), metadata.GetOrAddBlob(consoleWriteLineSignature)); // Get reference to Object's constructor. var parameterlessCtorSignature = new BlobBuilder(); new BlobEncoder(parameterlessCtorSignature). MethodSignature(isInstanceMethod: true). Parameters(0, returnType => returnType.Void(), parameters => { }); BlobHandle parameterlessCtorBlobIndex = metadata.GetOrAddBlob(parameterlessCtorSignature); MemberReferenceHandle objectCtorMemberRef = metadata.AddMemberReference( systemObjectTypeRef, metadata.GetOrAddString(".ctor"), parameterlessCtorBlobIndex); // Create signature for "void Main()" method. var mainSignature = new BlobBuilder(); new BlobEncoder(mainSignature). MethodSignature(). Parameters(0, returnType => returnType.Void(), parameters => { }); var methodBodyStream = new MethodBodyStreamEncoder(ilBuilder); var codeBuilder = new BlobBuilder(); InstructionEncoder il; // Emit IL for Program::.ctor il = new InstructionEncoder(codeBuilder); // ldarg.0 il.LoadArgument(0); // call instance void [mscorlib]System.Object::.ctor() il.Call(objectCtorMemberRef); // ret il.OpCode(ILOpCode.Ret); int ctorBodyOffset = methodBodyStream.AddMethodBody(il); codeBuilder.Clear(); // Emit IL for Program::Main var flowBuilder = new ControlFlowBuilder(); il = new InstructionEncoder(codeBuilder, flowBuilder); // ldstr "hello" il.LoadString(metadata.GetOrAddUserString("Hello, world")); // call void [mscorlib]System.Console::WriteLine(string) il.Call(consoleWriteLineMemberRef); // ret il.OpCode(ILOpCode.Ret); int mainBodyOffset = methodBodyStream.AddMethodBody(il); codeBuilder.Clear(); // Create method definition for Program::Main MethodDefinitionHandle mainMethodDef = metadata.AddMethodDefinition( MethodAttributes.Public | MethodAttributes.Static | MethodAttributes.HideBySig, MethodImplAttributes.IL, metadata.GetOrAddString("Main"), metadata.GetOrAddBlob(mainSignature), mainBodyOffset, parameterList: default(ParameterHandle)); // Create method definition for Program::.ctor MethodDefinitionHandle ctorDef = metadata.AddMethodDefinition( MethodAttributes.Public | MethodAttributes.HideBySig | MethodAttributes.SpecialName | MethodAttributes.RTSpecialName, MethodImplAttributes.IL, metadata.GetOrAddString(".ctor"), parameterlessCtorBlobIndex, ctorBodyOffset, parameterList: default(ParameterHandle)); // Create type definition for the special <Module> type that holds global functions metadata.AddTypeDefinition( default(TypeAttributes), default(StringHandle), metadata.GetOrAddString("<Module>"), baseType: default(EntityHandle), fieldList: MetadataTokens.FieldDefinitionHandle(1), methodList: mainMethodDef); // Create type definition for ConsoleApplication.Program metadata.AddTypeDefinition( TypeAttributes.Class | TypeAttributes.Public | TypeAttributes.AutoLayout | TypeAttributes.BeforeFieldInit, metadata.GetOrAddString("ConsoleApplication"), metadata.GetOrAddString("Program"), baseType: systemObjectTypeRef, fieldList: MetadataTokens.FieldDefinitionHandle(1), methodList: mainMethodDef); return(mainMethodDef); }
MethodDesc IR2RSignatureTypeProvider <TypeDesc, MethodDesc, R2RSigProviderContext> .GetMethodFromMemberRef(MetadataReader reader, MemberReferenceHandle handle, TypeDesc owningTypeOverride) { // Global signature cannot have MemberRef entries in them as such things aren't uniquely identifiable throw new NotSupportedException(); }
private uint GetMemberRefTreatmentAndRowId(MemberReferenceHandle handle) { // PERF: This code pattern is JIT friendly and results in very efficient code. if (this.metadataKind == MetadataKind.Ecma335) { return handle.RowId; } return CalculateMemberRefTreatmentAndRowId(handle); }
private static bool IsNil(MemberReferenceHandle x) => x.IsNil;
/// <summary> /// Resolves a method reference. /// </summary> /// <remarks> /// Class type arguments are provided by the declaring type stored in the memberRef. /// Method type arguments are provided by the caller. /// </remarks> IMethod ResolveMethodReference(MemberReferenceHandle memberRefHandle, GenericContext context, IReadOnlyList <IType> methodTypeArguments = null, bool expandVarArgs = true) { var memberRef = metadata.GetMemberReference(memberRefHandle); Debug.Assert(memberRef.GetKind() == MemberReferenceKind.Method); MethodSignature <IType> signature; IReadOnlyList <IType> classTypeArguments = null; IMethod method; if (memberRef.Parent.Kind == HandleKind.MethodDefinition) { method = ResolveMethodDefinition((MethodDefinitionHandle)memberRef.Parent, expandVarArgs: false); signature = memberRef.DecodeMethodSignature(TypeProvider, context); } else { var declaringType = ResolveDeclaringType(memberRef.Parent, context); var declaringTypeDefinition = declaringType.GetDefinition(); if (declaringType.TypeArguments.Count > 0) { classTypeArguments = declaringType.TypeArguments; } // Note: declaringType might be parameterized, but the signature is for the original method definition. // We'll have to search the member directly on declaringTypeDefinition. string name = metadata.GetString(memberRef.Name); signature = memberRef.DecodeMethodSignature(TypeProvider, new GenericContext(declaringTypeDefinition?.TypeParameters)); if (declaringTypeDefinition != null) { // Find the set of overloads to search: IEnumerable <IMethod> methods; if (name == ".ctor") { methods = declaringTypeDefinition.GetConstructors(); } else if (name == ".cctor") { methods = declaringTypeDefinition.Methods.Where(m => m.IsConstructor && m.IsStatic); } else { methods = declaringTypeDefinition.GetMethods(m => m.Name == name, GetMemberOptions.IgnoreInheritedMembers) .Concat(declaringTypeDefinition.GetAccessors(m => m.Name == name, GetMemberOptions.IgnoreInheritedMembers)); } // Determine the expected parameters from the signature: ImmutableArray <IType> parameterTypes; if (signature.Header.CallingConvention == SignatureCallingConvention.VarArgs) { parameterTypes = signature.ParameterTypes .Take(signature.RequiredParameterCount) .Concat(new[] { SpecialType.ArgList }) .ToImmutableArray(); } else { parameterTypes = signature.ParameterTypes; } // Search for the matching method: method = null; foreach (var m in methods) { if (m.TypeParameters.Count != signature.GenericParameterCount) { continue; } if (CompareSignatures(m.Parameters, parameterTypes) && CompareTypes(m.ReturnType, signature.ReturnType)) { method = m; break; } } } else { method = null; } if (method == null) { method = CreateFakeMethod(declaringType, name, signature); } } if (classTypeArguments != null || methodTypeArguments != null) { method = method.Specialize(new TypeParameterSubstitution(classTypeArguments, methodTypeArguments)); } if (expandVarArgs && signature.Header.CallingConvention == SignatureCallingConvention.VarArgs) { method = new VarArgInstanceMethod(method, signature.ParameterTypes.Skip(signature.RequiredParameterCount)); } return(method); }
internal BlobHandle GetSignature(MemberReferenceHandle handle) { int rowOffset = (int)(handle.RowId - 1) * this.RowSize; return BlobHandle.FromIndex(this.Block.PeekReference(rowOffset + this.SignatureOffset, this.IsBlobHeapRefSizeSmall)); }