public MethodSignatureComparer( QMethodDefinition methodHandle) { if (methodHandle.IsNativeFormatMetadataBased) { _metadataReader = methodHandle.NativeFormatReader; _methodHandle = methodHandle.NativeFormatHandle; _method = _methodHandle.GetMethod(_metadataReader); _methodSignature = _method.Signature.GetMethodSignature(_metadataReader); _isGeneric = (_methodSignature.GenericParameterCount != 0); // Precalculate initial method attributes used in signature queries _isStatic = (_method.Flags & MethodAttributes.Static) != 0; } else { _metadataReader = null; _methodHandle = default(MethodHandle); _method = default(Method); _methodSignature = default(MethodSignature); _isGeneric = false; _isStatic = false; } }
private bool GetAccessor(MethodSemanticsAttributes methodSemanticsAttribute, out MethodHandle methodHandle) { bool inherited = !_reflectedType.Equals(_contextTypeInfo); foreach (MethodSemanticsHandle methodSemanticsHandle in _property.MethodSemantics) { MethodSemantics methodSemantics = methodSemanticsHandle.GetMethodSemantics(_reader); if (methodSemantics.Attributes == methodSemanticsAttribute) { methodHandle = methodSemantics.Method; if (inherited) { MethodAttributes flags = methodHandle.GetMethod(_reader).Flags; if ((flags & MethodAttributes.MemberAccessMask) == MethodAttributes.Private) { continue; } } return(true); } } methodHandle = default(MethodHandle); return(false); }
// // methodHandle - the "tkMethodDef" that identifies the method. // definingType - the "tkTypeDef" that defined the method (this is where you get the metadata reader that created methodHandle.) // contextType - the type that supplies the type context (i.e. substitutions for generic parameters.) Though you // get your raw information from "definingType", you report "contextType" as your DeclaringType property. // // For example: // // typeof(Foo<>).GetTypeInfo().DeclaredMembers // // The definingType and contextType are both Foo<> // // typeof(Foo<int,String>).GetTypeInfo().DeclaredMembers // // The definingType is "Foo<,>" // The contextType is "Foo<int,String>" // // We don't report any DeclaredMembers for arrays or generic parameters so those don't apply. // public NativeFormatMethodCommon(MethodHandle methodHandle, NativeFormatRuntimeNamedTypeInfo definingTypeInfo, RuntimeTypeInfo contextTypeInfo) { _definingTypeInfo = definingTypeInfo; _methodHandle = methodHandle; _contextTypeInfo = contextTypeInfo; _reader = definingTypeInfo.Reader; _method = methodHandle.GetMethod(_reader); }
// // methodHandle - the "tkMethodDef" that identifies the method. // definingType - the "tkTypeDef" that defined the method (this is where you get the metadata reader that created methodHandle.) // contextType - the type that supplies the type context (i.e. substitutions for generic parameters.) Though you // get your raw information from "definingType", you report "contextType" as your DeclaringType property. // // For example: // // typeof(Foo<>).GetTypeInfo().DeclaredMembers // // The definingType and contextType are both Foo<> // // typeof(Foo<int,String>).GetTypeInfo().DeclaredMembers // // The definingType is "Foo<,>" // The contextType is "Foo<int,String>" // // We don't report any DeclaredMembers for arrays or generic parameters so those don't apply. // public RuntimeMethodCommon(MethodHandle methodHandle, RuntimeNamedTypeInfo definingTypeInfo, RuntimeTypeInfo contextTypeInfo) { _definingTypeInfo = definingTypeInfo; _methodHandle = methodHandle; _contextTypeInfo = contextTypeInfo; _reader = definingTypeInfo.Reader; _method = methodHandle.GetMethod(_reader); }
public NullableInstanceMethodInvoker(MetadataReader reader, MethodHandle methodHandle, RuntimeTypeHandle nullableTypeHandle, MethodInvokeInfo methodInvokeInfo) { _id = NullableMethodId.None; _nullableTypeHandle = nullableTypeHandle; Method method = methodHandle.GetMethod(reader); if (MethodAttributes.Public == (method.Flags & MethodAttributes.MemberAccessMask)) { // Note: Since we control the definition of Nullable<>, we're not checking signatures here. String name = method.Name.GetConstantStringValue(reader).Value; switch (name) { case "GetType": _id = NullableMethodId.GetType; break; case "ToString": _id = NullableMethodId.ToString; break; case "Equals": _id = NullableMethodId.Equals; break; case "GetHashCode": _id = NullableMethodId.GetHashCode; break; case ".ctor": _id = NullableMethodId.Ctor; break; case "get_HasValue": _id = NullableMethodId.get_HasValue; break; case "get_Value": _id = NullableMethodId.get_Value; break; case "GetValueOrDefault": IEnumerator <Handle> parameters = method.Signature.GetMethodSignature(reader).Parameters.GetEnumerator(); if (parameters.MoveNext()) { _id = NullableMethodId.GetValueOrDefault_1; } else { _id = NullableMethodId.GetValueOrDefault_0; } break; default: break; } } }
public sealed override IEnumerable <CustomAttributeData> GetPsuedoCustomAttributes(MetadataReader reader, MethodHandle methodHandle, TypeDefinitionHandle declaringTypeHandle) { MethodImplAttributes implAttributes = methodHandle.GetMethod(reader).ImplFlags; if (0 != (implAttributes & MethodImplAttributes.PreserveSig)) { yield return(ReflectionCoreExecution.ExecutionDomain.GetCustomAttributeData(typeof(PreserveSigAttribute), null, null)); } }
// // Creates the appropriate flavor of Invoker depending on the calling convention "shape" (static, instance or virtual.) // internal static MethodInvoker CreateMethodInvoker(MetadataReader reader, RuntimeTypeHandle declaringTypeHandle, MethodHandle methodHandle, MethodInvokeInfo methodInvokeInfo) { Method method = methodHandle.GetMethod(reader); MethodAttributes methodAttributes = method.Flags; if (0 != (methodAttributes & MethodAttributes.Static)) return new StaticMethodInvoker(methodInvokeInfo); else if (methodInvokeInfo.VirtualResolveData != IntPtr.Zero) return new VirtualMethodInvoker(methodInvokeInfo, declaringTypeHandle); else return new InstanceMethodInvoker(methodInvokeInfo, declaringTypeHandle); }
public NullableInstanceMethodInvoker(MetadataReader reader, MethodHandle methodHandle, RuntimeTypeHandle nullableTypeHandle, MethodInvokeInfo methodInvokeInfo) { _id = NullableMethodId.None; _nullableTypeHandle = nullableTypeHandle; Method method = methodHandle.GetMethod(reader); if (MethodAttributes.Public == (method.Flags & MethodAttributes.MemberAccessMask)) { // Note: Since we control the definition of Nullable<>, we're not checking signatures here. String name = method.Name.GetConstantStringValue(reader).Value; switch (name) { case "GetType": _id = NullableMethodId.GetType; break; case "ToString": _id = NullableMethodId.ToString; break; case "Equals": _id = NullableMethodId.Equals; break; case "GetHashCode": _id = NullableMethodId.GetHashCode; break; case ".ctor": _id = NullableMethodId.Ctor; break; case "get_HasValue": _id = NullableMethodId.get_HasValue; break; case "get_Value": _id = NullableMethodId.get_Value; break; case "GetValueOrDefault": IEnumerator<ParameterTypeSignatureHandle> parameters = method.Signature.GetMethodSignature(reader).Parameters.GetEnumerator(); if (parameters.MoveNext()) _id = NullableMethodId.GetValueOrDefault_1; else _id = NullableMethodId.GetValueOrDefault_0; break; default: break; } } }
/// <summary> /// Emit parenthesized method argument type list with parameter names. /// </summary> /// <param name="methodHandle">Method handle to use for parameter formatting</param> private void EmitMethodParameters(MethodHandle methodHandle) { bool TryGetNextParameter(ref ParameterHandleCollection.Enumerator enumerator, out Parameter parameter) { bool hasNext = enumerator.MoveNext(); parameter = hasNext ? enumerator.Current.GetParameter(_metadataReader) : default; return(hasNext); } Method method = methodHandle.GetMethod(_metadataReader); HandleCollection typeVector = method.Signature.GetMethodSignature(_metadataReader).Parameters; ParameterHandleCollection.Enumerator parameters = method.Parameters.GetEnumerator(); bool hasParameter = TryGetNextParameter(ref parameters, out Parameter parameter); if (hasParameter && parameter.Sequence == 0) { hasParameter = TryGetNextParameter(ref parameters, out parameter); } _outputBuilder.Append('('); uint typeIndex = 0; foreach (Handle type in typeVector) { if (typeIndex != 0) { _outputBuilder.Append(", "); } EmitTypeName(type, namespaceQualified: false); if (++typeIndex == parameter.Sequence && hasParameter) { string name = parameter.Name.GetConstantStringValue(_metadataReader).Value; hasParameter = TryGetNextParameter(ref parameters, out parameter); if (!string.IsNullOrEmpty(name)) { _outputBuilder.Append(' '); _outputBuilder.Append(name); } } } _outputBuilder.Append(')'); }
/// <summary> /// Construct a comparer between NativeFormat metadata methods and native layouts /// </summary> /// <param name="metadataReader">Metadata reader for the method declaring type</param> /// <param name="methodHandle">Handle of method to compare</param> public MethodSignatureComparer( MetadataReader metadataReader, MethodHandle methodHandle) { _metadataReader = metadataReader; _methodHandle = methodHandle; _method = methodHandle.GetMethod(metadataReader); _methodSignature = _method.Signature.GetMethodSignature(_metadataReader); _isGeneric = (_methodSignature.GenericParameterCount != 0); // Precalculate initial method attributes used in signature queries _isStatic = (_method.Flags & MethodAttributes.Static) != 0; }
public RuntimeTypeInfo[] GetGenericTypeParametersWithSpecifiedOwningMethod(RuntimeNamedMethodInfo<NativeFormatMethodCommon> owningMethod) { Method method = MethodHandle.GetMethod(Reader); int genericParametersCount = method.GenericParameters.Count; if (genericParametersCount == 0) return Array.Empty<RuntimeTypeInfo>(); RuntimeTypeInfo[] genericTypeParameters = new RuntimeTypeInfo[genericParametersCount]; int i = 0; foreach (GenericParameterHandle genericParameterHandle in method.GenericParameters) { RuntimeTypeInfo genericParameterType = NativeFormatRuntimeGenericParameterTypeInfoForMethods.GetRuntimeGenericParameterTypeInfoForMethods(owningMethod, Reader, genericParameterHandle); genericTypeParameters[i++] = genericParameterType; } return genericTypeParameters; }
// // Creates the appropriate flavor of Invoker depending on the calling convention "shape" (static, instance or virtual.) // internal static MethodInvoker CreateMethodInvoker(MetadataReader reader, RuntimeTypeHandle declaringTypeHandle, MethodHandle methodHandle, MethodInvokeInfo methodInvokeInfo) { Method method = methodHandle.GetMethod(reader); MethodAttributes methodAttributes = method.Flags; if (0 != (methodAttributes & MethodAttributes.Static)) { return(new StaticMethodInvoker(methodInvokeInfo)); } else if (methodInvokeInfo.VirtualResolveData != IntPtr.Zero) { return(new VirtualMethodInvoker(methodInvokeInfo, declaringTypeHandle)); } else { return(new InstanceMethodInvoker(methodInvokeInfo, declaringTypeHandle)); } }
public IntPtrConstructorMethodInvoker(MetadataReader reader, MethodHandle methodHandle) { // Since we control the definition of System.IntPtr, we only do enough analysis of the signature to disambiguate the constructors we support. _id = IntPtrConstructorId.None; Method method = methodHandle.GetMethod(reader); HandleCollection parameterTypeSignatureHandles = method.Signature.GetMethodSignature(reader).Parameters; if (parameterTypeSignatureHandles.Count == 1) { HandleCollection.Enumerator enumerator = parameterTypeSignatureHandles.GetEnumerator(); enumerator.MoveNext(); Handle parameterTypeHandle = enumerator.Current; // If any parameter is a pointer type, bail as we don't support Invokes on pointers. if (parameterTypeHandle.HandleType != HandleType.TypeDefinition) { throw new PlatformNotSupportedException(SR.PlatformNotSupported_PointerArguments); } TypeDefinition typeDefinition = parameterTypeHandle.ToTypeDefinitionHandle(reader).GetTypeDefinition(reader); String name = typeDefinition.Name.GetString(reader); switch (name) { case "Int32": _id = IntPtrConstructorId.Int32; break; case "Int64": _id = IntPtrConstructorId.Int64; break; case "UInt32": _id = IntPtrConstructorId.UInt32; break; case "UInt64": _id = IntPtrConstructorId.UInt64; break; default: break; } } }
protected sealed override RuntimeNamedMethodInfo GetPropertyMethod(PropertyMethodSemantics whichMethod) { NativeFormatMethodSemanticsAttributes localMethodSemantics; switch (whichMethod) { case PropertyMethodSemantics.Getter: localMethodSemantics = NativeFormatMethodSemanticsAttributes.Getter; break; case PropertyMethodSemantics.Setter: localMethodSemantics = NativeFormatMethodSemanticsAttributes.Setter; break; default: return(null); } bool inherited = !_reflectedType.Equals(ContextTypeInfo); foreach (MethodSemanticsHandle methodSemanticsHandle in _property.MethodSemantics) { MethodSemantics methodSemantics = methodSemanticsHandle.GetMethodSemantics(_reader); if (methodSemantics.Attributes == localMethodSemantics) { MethodHandle methodHandle = methodSemantics.Method; if (inherited) { MethodAttributes flags = methodHandle.GetMethod(_reader).Flags; if ((flags & MethodAttributes.MemberAccessMask) == MethodAttributes.Private) { continue; } } return(RuntimeNamedMethodInfo <NativeFormatMethodCommon> .GetRuntimeNamedMethodInfo(new NativeFormatMethodCommon(methodHandle, _definingTypeInfo, ContextTypeInfo), _reflectedType)); } } return(null); }
public StringConstructorMethodInvoker(MetadataReader reader, MethodHandle methodHandle) { // Since we control the definition of System.String, we only do enough analysis of the signature to disambiguate the constructors we support. _id = StringConstructorId.None; Method method = methodHandle.GetMethod(reader); int parameterCount = 0; foreach (ParameterTypeSignatureHandle parameterTypeSignatureHandle in method.Signature.GetMethodSignature(reader).Parameters) { ParameterTypeSignature parameterTypeSignature = parameterTypeSignatureHandle.GetParameterTypeSignature(reader); // If any parameter is a pointer type, bail as we don't support Invokes on pointers. if (parameterTypeSignature.Type.HandleType == HandleType.TypeSpecification) { TypeSpecification typeSpecification = parameterTypeSignature.Type.ToTypeSpecificationHandle(reader).GetTypeSpecification(reader); if (typeSpecification.Signature.HandleType == HandleType.PointerSignature) { return; } } parameterCount++; } switch (parameterCount) { case 1: _id = StringConstructorId.CharArray; break; case 2: _id = StringConstructorId.Char_Int; break; case 3: _id = StringConstructorId.CharArray_Int_Int; break; default: break; } }
public IntPtrConstructorMethodInvoker(MetadataReader reader, MethodHandle methodHandle) { // Since we control the definition of System.IntPtr, we only do enough analysis of the signature to disambiguate the constructors we support. _id = IntPtrConstructorId.None; Method method = methodHandle.GetMethod(reader); ParameterTypeSignatureHandle[] parameterTypeSignatureHandles = method.Signature.GetMethodSignature(reader).Parameters.ToArray(); if (parameterTypeSignatureHandles.Length == 1) { ParameterTypeSignature parameterTypeSignature = parameterTypeSignatureHandles[0].GetParameterTypeSignature(reader); // If any parameter is a pointer type, bail as we don't support Invokes on pointers. if (parameterTypeSignature.Type.HandleType != HandleType.TypeDefinition) throw new PlatformNotSupportedException(SR.PlatformNotSupported_PointerArguments); TypeDefinition typeDefinition = parameterTypeSignature.Type.ToTypeDefinitionHandle(reader).GetTypeDefinition(reader); String name = typeDefinition.Name.GetString(reader); switch (name) { case "Int32": _id = IntPtrConstructorId.Int32; break; case "Int64": _id = IntPtrConstructorId.Int64; break; case "UInt32": _id = IntPtrConstructorId.UInt32; break; case "UInt64": _id = IntPtrConstructorId.UInt64; break; default: break; } } }
public StringConstructorMethodInvoker(MetadataReader reader, MethodHandle methodHandle) { // Since we control the definition of System.String, we only do enough analysis of the signature to disambiguate the constructors we support. _id = StringConstructorId.None; Method method = methodHandle.GetMethod(reader); int parameterCount = 0; foreach (ParameterTypeSignatureHandle parameterTypeSignatureHandle in method.Signature.GetMethodSignature(reader).Parameters) { ParameterTypeSignature parameterTypeSignature = parameterTypeSignatureHandle.GetParameterTypeSignature(reader); // If any parameter is a pointer type, bail as we don't support Invokes on pointers. if (parameterTypeSignature.Type.HandleType == HandleType.TypeSpecification) { TypeSpecification typeSpecification = parameterTypeSignature.Type.ToTypeSpecificationHandle(reader).GetTypeSpecification(reader); if (typeSpecification.Signature.HandleType == HandleType.PointerSignature) return; } parameterCount++; } switch (parameterCount) { case 1: _id = StringConstructorId.CharArray; break; case 2: _id = StringConstructorId.Char_Int; break; case 3: _id = StringConstructorId.CharArray_Int_Int; break; default: break; } }
// // Used to split methods between DeclaredMethods and DeclaredConstructors. // public static bool IsConstructor(this MethodHandle methodHandle, MetadataReader reader) { Method method = methodHandle.GetMethod(reader); return(IsConstructor(ref method, reader)); }
public sealed override IEnumerable<CustomAttributeData> GetPsuedoCustomAttributes(MetadataReader reader, MethodHandle methodHandle, TypeDefinitionHandle declaringTypeHandle) { MethodImplAttributes implAttributes = methodHandle.GetMethod(reader).ImplFlags; if (0 != (implAttributes & MethodImplAttributes.PreserveSig)) yield return ReflectionCoreExecution.ExecutionDomain.GetCustomAttributeData(typeof(PreserveSigAttribute), null, null); }