protected RuntimeMethodParameterInfo(MethodBase member, int position, MetadataReader reader, Handle typeHandle, TypeContext typeContext) : base(member, position) { Reader = reader; _typeHandle = typeHandle; _typeContext = typeContext; }
private RuntimeFatMethodParameterInfo(MethodBase member, MethodHandle methodHandle, int position, ParameterHandle parameterHandle, MetadataReader reader, Handle typeHandle, TypeContext typeContext) : base(member, position, reader, typeHandle, typeContext) { _methodHandle = methodHandle; _parameterHandle = parameterHandle; _parameter = parameterHandle.GetParameter(reader); }
private NativeFormatMethodParameterInfo(MethodBase member, MethodHandle methodHandle, int position, ParameterHandle parameterHandle, QTypeDefRefOrSpec qualifiedParameterTypeHandle, TypeContext typeContext) : base(member, position, qualifiedParameterTypeHandle, typeContext) { _methodHandle = methodHandle; _parameterHandle = parameterHandle; _parameter = parameterHandle.GetParameter(Reader); }
// // Main routine to resolve a typeDef/Ref/Spec. // internal static RuntimeTypeInfo Resolve(this QTypeDefRefOrSpec typeDefOrRefOrSpec, TypeContext typeContext) { Exception exception = null; RuntimeTypeInfo runtimeType = typeDefOrRefOrSpec.TryResolve(typeContext, ref exception); if (runtimeType == null) throw exception; return runtimeType; }
// // Main routine to resolve a typeDef/Ref/Spec. // internal static RuntimeTypeInfo Resolve(this Handle typeDefRefOrSpec, MetadataReader reader, TypeContext typeContext) { Exception exception = null; RuntimeTypeInfo runtimeType = typeDefRefOrSpec.TryResolve(reader, typeContext, ref exception); if (runtimeType == null) throw exception; return runtimeType; }
// // Main routine to resolve a typeDef/Ref/Spec. // internal static RuntimeType Resolve(this ReflectionDomain reflectionDomain, MetadataReader reader, Handle typeDefRefOrSpec, TypeContext typeContext) { Exception exception = null; RuntimeType runtimeType = reflectionDomain.TryResolve(reader, typeDefRefOrSpec, typeContext, ref exception); if (runtimeType == null) throw exception; return runtimeType; }
internal static RuntimeTypeInfo TryResolve(this QTypeDefRefOrSpec typeDefOrRefOrSpec, TypeContext typeContext, ref Exception exception) { if (typeDefOrRefOrSpec.IsNativeFormatMetadataBased) { return global::Internal.Metadata.NativeFormat.Handle.FromIntToken(typeDefOrRefOrSpec.Handle).TryResolve((global::Internal.Metadata.NativeFormat.MetadataReader)typeDefOrRefOrSpec.Reader, typeContext, ref exception); } throw new BadImageFormatException(); // Expected TypeRef, Def or Spec with MetadataReader }
internal static RuntimeType TryResolve(this ReflectionDomain reflectionDomain, MetadataReader reader, Handle typeDefRefOrSpec, TypeContext typeContext, ref Exception exception) { HandleType handleType = typeDefRefOrSpec.HandleType; if (handleType == HandleType.TypeDefinition) return reflectionDomain.ResolveTypeDefinition(reader, typeDefRefOrSpec.ToTypeDefinitionHandle(reader)); else if (handleType == HandleType.TypeReference) return reflectionDomain.TryResolveTypeReference(reader, typeDefRefOrSpec.ToTypeReferenceHandle(reader), ref exception); else if (handleType == HandleType.TypeSpecification) return reflectionDomain.TryResolveTypeSignature(reader, typeDefRefOrSpec.ToTypeSpecificationHandle(reader), typeContext, ref exception); else throw new BadImageFormatException(); // Expected TypeRef, Def or Spec. }
// // This is a port of the desktop CLR's RuntimeType.FormatTypeName() routine. This routine is used by various Reflection ToString() methods // to display the name of a type. Do not use for any other purpose as it inherits some pretty quirky desktop behavior. // // The Project N version takes a raw metadata handle rather than a completed type so that it remains robust in the face of missing metadata. // public static String FormatTypeName(this QTypeDefRefOrSpec qualifiedTypeHandle, TypeContext typeContext) { try { // Though we wrap this in a try-catch as a failsafe, this code must still strive to avoid triggering MissingMetadata exceptions // (non-error exceptions are very annoying when debugging.) Exception exception = null; RuntimeTypeInfo runtimeType = qualifiedTypeHandle.TryResolve(typeContext, ref exception); if (runtimeType == null) return UnavailableType; // Because this runtimeType came from a successful TryResolve() call, it is safe to querying the TypeInfo's of the type and its component parts. // If we're wrong, we do have the safety net of a try-catch. return runtimeType.FormatTypeName(); } catch (Exception) { return UnavailableType; } }
// // Main routine to parse a metadata type specification signature. // private static RuntimeType TryResolveTypeSignature(this ReflectionDomain reflectionDomain, MetadataReader reader, TypeSpecificationHandle typeSpecHandle, TypeContext typeContext, ref Exception exception) { Handle typeHandle = typeSpecHandle.GetTypeSpecification(reader).Signature; switch (typeHandle.HandleType) { case HandleType.ArraySignature: { ArraySignature sig = typeHandle.ToArraySignatureHandle(reader).GetArraySignature(reader); int rank = sig.Rank; if (rank <= 0) throw new BadImageFormatException(); // Bad rank. RuntimeType elementType = reflectionDomain.TryResolve(reader, sig.ElementType, typeContext, ref exception); if (elementType == null) return null; return ReflectionCoreNonPortable.GetMultiDimArrayType(elementType, rank); } case HandleType.ByReferenceSignature: { ByReferenceSignature sig = typeHandle.ToByReferenceSignatureHandle(reader).GetByReferenceSignature(reader); RuntimeType targetType = reflectionDomain.TryResolve(reader, sig.Type, typeContext, ref exception); if (targetType == null) return null; return ReflectionCoreNonPortable.GetByRefType(targetType); } case HandleType.MethodTypeVariableSignature: { MethodTypeVariableSignature sig = typeHandle.ToMethodTypeVariableSignatureHandle(reader).GetMethodTypeVariableSignature(reader); return typeContext.GenericMethodArguments[sig.Number]; } case HandleType.PointerSignature: { PointerSignature sig = typeHandle.ToPointerSignatureHandle(reader).GetPointerSignature(reader); RuntimeType targetType = reflectionDomain.TryResolve(reader, sig.Type, typeContext, ref exception); if (targetType == null) return null; return ReflectionCoreNonPortable.GetPointerType(targetType); } case HandleType.SZArraySignature: { SZArraySignature sig = typeHandle.ToSZArraySignatureHandle(reader).GetSZArraySignature(reader); RuntimeType elementType = reflectionDomain.TryResolve(reader, sig.ElementType, typeContext, ref exception); if (elementType == null) return null; return ReflectionCoreNonPortable.GetArrayType(elementType); } case HandleType.TypeDefinition: { return reflectionDomain.ResolveTypeDefinition(reader, typeHandle.ToTypeDefinitionHandle(reader)); } case HandleType.TypeInstantiationSignature: { TypeInstantiationSignature sig = typeHandle.ToTypeInstantiationSignatureHandle(reader).GetTypeInstantiationSignature(reader); RuntimeType genericTypeDefinition = reflectionDomain.TryResolve(reader, sig.GenericType, typeContext, ref exception); if (genericTypeDefinition == null) return null; LowLevelList<RuntimeType> genericTypeArguments = new LowLevelList<RuntimeType>(); foreach (Handle genericTypeArgumentHandle in sig.GenericTypeArguments) { RuntimeType genericTypeArgument = reflectionDomain.TryResolve(reader, genericTypeArgumentHandle, typeContext, ref exception); if (genericTypeArgument == null) return null; genericTypeArguments.Add(genericTypeArgument); } return ReflectionCoreNonPortable.GetConstructedGenericType(genericTypeDefinition, genericTypeArguments.ToArray()); } case HandleType.TypeReference: { return reflectionDomain.TryResolveTypeReference(reader, typeHandle.ToTypeReferenceHandle(reader), ref exception); } case HandleType.TypeVariableSignature: { TypeVariableSignature sig = typeHandle.ToTypeVariableSignatureHandle(reader).GetTypeVariableSignature(reader); return typeContext.GenericTypeArguments[sig.Number]; } default: throw new NotSupportedException(); // Unexpected Type signature type. } }
// // Main routine to resolve a typeDef/Ref/Spec. Also accepts ModifiedTypes (will unwrap and ignore the custom modifiers.) // internal static RuntimeTypeInfo Resolve(this Handle typeDefRefOrSpec, MetadataReader reader, TypeContext typeContext) { Exception? exception = null; RuntimeTypeInfo?runtimeType = typeDefRefOrSpec.TryResolve(reader, typeContext, ref exception); if (runtimeType == null) { throw exception !; } return(runtimeType); }
internal static RuntimeType TryResolve(this ReflectionDomain reflectionDomain, MetadataReader reader, Handle typeDefRefOrSpec, TypeContext typeContext, ref Exception exception) { HandleType handleType = typeDefRefOrSpec.HandleType; if (handleType == HandleType.TypeDefinition) { return(reflectionDomain.ResolveTypeDefinition(reader, typeDefRefOrSpec.ToTypeDefinitionHandle(reader))); } else if (handleType == HandleType.TypeReference) { return(reflectionDomain.TryResolveTypeReference(reader, typeDefRefOrSpec.ToTypeReferenceHandle(reader), ref exception)); } else if (handleType == HandleType.TypeSpecification) { return(reflectionDomain.TryResolveTypeSignature(reader, typeDefRefOrSpec.ToTypeSpecificationHandle(reader), typeContext, ref exception)); } else { throw new BadImageFormatException(); // Expected TypeRef, Def or Spec. } }
// // Main routine to resolve a typeDef/Ref/Spec. // internal static RuntimeType Resolve(this ReflectionDomain reflectionDomain, MetadataReader reader, Handle typeDefRefOrSpec, TypeContext typeContext) { Exception exception = null; RuntimeType runtimeType = reflectionDomain.TryResolve(reader, typeDefRefOrSpec, typeContext, ref exception); if (runtimeType == null) { throw exception; } return(runtimeType); }
// // Main routine to parse a metadata type specification signature. // private static RuntimeType TryResolveTypeSignature(this ReflectionDomain reflectionDomain, MetadataReader reader, TypeSpecificationHandle typeSpecHandle, TypeContext typeContext, ref Exception exception) { Handle typeHandle = typeSpecHandle.GetTypeSpecification(reader).Signature; switch (typeHandle.HandleType) { case HandleType.ArraySignature: { ArraySignature sig = typeHandle.ToArraySignatureHandle(reader).GetArraySignature(reader); int rank = sig.Rank; if (rank <= 0) { throw new BadImageFormatException(); // Bad rank. } RuntimeType elementType = reflectionDomain.TryResolve(reader, sig.ElementType, typeContext, ref exception); if (elementType == null) { return(null); } return(ReflectionCoreNonPortable.GetMultiDimArrayType(elementType, rank)); } case HandleType.ByReferenceSignature: { ByReferenceSignature sig = typeHandle.ToByReferenceSignatureHandle(reader).GetByReferenceSignature(reader); RuntimeType targetType = reflectionDomain.TryResolve(reader, sig.Type, typeContext, ref exception); if (targetType == null) { return(null); } return(ReflectionCoreNonPortable.GetByRefType(targetType)); } case HandleType.MethodTypeVariableSignature: { MethodTypeVariableSignature sig = typeHandle.ToMethodTypeVariableSignatureHandle(reader).GetMethodTypeVariableSignature(reader); return(typeContext.GenericMethodArguments[sig.Number]); } case HandleType.PointerSignature: { PointerSignature sig = typeHandle.ToPointerSignatureHandle(reader).GetPointerSignature(reader); RuntimeType targetType = reflectionDomain.TryResolve(reader, sig.Type, typeContext, ref exception); if (targetType == null) { return(null); } return(ReflectionCoreNonPortable.GetPointerType(targetType)); } case HandleType.SZArraySignature: { SZArraySignature sig = typeHandle.ToSZArraySignatureHandle(reader).GetSZArraySignature(reader); RuntimeType elementType = reflectionDomain.TryResolve(reader, sig.ElementType, typeContext, ref exception); if (elementType == null) { return(null); } return(ReflectionCoreNonPortable.GetArrayType(elementType)); } case HandleType.TypeDefinition: { return(reflectionDomain.ResolveTypeDefinition(reader, typeHandle.ToTypeDefinitionHandle(reader))); } case HandleType.TypeInstantiationSignature: { TypeInstantiationSignature sig = typeHandle.ToTypeInstantiationSignatureHandle(reader).GetTypeInstantiationSignature(reader); RuntimeType genericTypeDefinition = reflectionDomain.TryResolve(reader, sig.GenericType, typeContext, ref exception); if (genericTypeDefinition == null) { return(null); } LowLevelList <RuntimeType> genericTypeArguments = new LowLevelList <RuntimeType>(); foreach (Handle genericTypeArgumentHandle in sig.GenericTypeArguments) { RuntimeType genericTypeArgument = reflectionDomain.TryResolve(reader, genericTypeArgumentHandle, typeContext, ref exception); if (genericTypeArgument == null) { return(null); } genericTypeArguments.Add(genericTypeArgument); } return(ReflectionCoreNonPortable.GetConstructedGenericType(genericTypeDefinition, genericTypeArguments.ToArray())); } case HandleType.TypeReference: { return(reflectionDomain.TryResolveTypeReference(reader, typeHandle.ToTypeReferenceHandle(reader), ref exception)); } case HandleType.TypeVariableSignature: { TypeVariableSignature sig = typeHandle.ToTypeVariableSignatureHandle(reader).GetTypeVariableSignature(reader); return(typeContext.GenericTypeArguments[sig.Number]); } default: throw new NotSupportedException(); // Unexpected Type signature type. } }
private RuntimeThinMethodParameterInfo(MethodBase member, int position, QTypeDefRefOrSpec qualifiedParameterTypeHandle, TypeContext typeContext) : base(member, position, qualifiedParameterTypeHandle, typeContext) { }
// Return any custom modifiers modifying the passed-in type and whose required/optional bit matches the passed in boolean. // Because this is intended to service the GetCustomModifiers() apis, this helper will always return a freshly allocated array // safe for returning to api callers. internal static Type[] GetCustomModifiers(this Handle handle, MetadataReader reader, TypeContext typeContext, bool optional) { HandleType handleType = handle.HandleType; Debug.Assert(handleType == HandleType.TypeDefinition || handleType == HandleType.TypeReference || handleType == HandleType.TypeSpecification || handleType == HandleType.ModifiedType); if (handleType != HandleType.ModifiedType) { return(Array.Empty <Type>()); } LowLevelList <Type> customModifiers = new LowLevelList <Type>(); do { ModifiedType modifiedType = handle.ToModifiedTypeHandle(reader).GetModifiedType(reader); if (optional == modifiedType.IsOptional) { Type customModifier = modifiedType.ModifierType.Resolve(reader, typeContext); customModifiers.Insert(0, customModifier); } handle = modifiedType.Type; handleType = handle.HandleType; }while (handleType == HandleType.ModifiedType); return(customModifiers.ToArray()); }
protected RuntimeMethodParameterInfo(MethodBase member, int position, QTypeDefRefOrSpec qualifiedParameterTypeHandle, TypeContext typeContext) : base(member, position) { QualifiedParameterTypeHandle = qualifiedParameterTypeHandle; _typeContext = typeContext; }
// // Returns the ParameterInfo objects for the return parameter (in element 0), and the method parameters (in elements 1..length). // // The ParameterInfo objects will report "contextMethod" as their Member property and use it to get type variable information from // the contextMethod's declaring type. The actual metadata, however, comes from "this." // // The methodTypeArguments provides the fill-ins for any method type variable elements in the parameter type signatures. // // Does not array-copy. // public RuntimeMethodParameterInfo[] GetRuntimeParametersAndReturn(MethodBase contextMethod, RuntimeTypeInfo[] methodTypeArguments) { MetadataReader reader = _reader; TypeContext typeContext = contextMethod.DeclaringType.CastToRuntimeTypeInfo().TypeContext; typeContext = new TypeContext(typeContext.GenericTypeArguments, methodTypeArguments); MethodSignature methodSignature = this.MethodSignature; Handle[] typeSignatures = new Handle[methodSignature.Parameters.Count + 1]; typeSignatures[0] = methodSignature.ReturnType; int paramIndex = 1; foreach (Handle parameterTypeSignatureHandle in methodSignature.Parameters) { typeSignatures[paramIndex++] = parameterTypeSignatureHandle; } int count = typeSignatures.Length; RuntimeMethodParameterInfo[] result = new RuntimeMethodParameterInfo[count]; foreach (ParameterHandle parameterHandle in _method.Parameters) { Parameter parameterRecord = parameterHandle.GetParameter(_reader); int index = parameterRecord.Sequence; result[index] = RuntimeFatMethodParameterInfo.GetRuntimeFatMethodParameterInfo( contextMethod, _methodHandle, index - 1, parameterHandle, reader, typeSignatures[index], typeContext); } for (int i = 0; i < count; i++) { if (result[i] == null) { result[i] = RuntimeThinMethodParameterInfo.GetRuntimeThinMethodParameterInfo( contextMethod, i - 1, reader, typeSignatures[i], typeContext); } } return result; }
// Return any custom modifiers modifying the passed-in type and whose required/optional bit matches the passed in boolean. // Because this is intended to service the GetCustomModifiers() apis, this helper will always return a freshly allocated array // safe for returning to api callers. internal Type[] GetCustomModifiers(TypeContext typeContext, bool optional) { #if ECMA_METADATA_SUPPORT throw new NotImplementedException(); #else return(_handle.GetCustomModifiers((global::Internal.Metadata.NativeFormat.MetadataReader)Reader, typeContext, optional)); #endif }
private RuntimeThinMethodParameterInfo(MethodBase member, int position, MetadataReader reader, Handle typeHandle, TypeContext typeContext) : base(member, position, reader, typeHandle, typeContext) { }
internal static RuntimeTypeInfo?TryResolve(this Handle typeDefRefOrSpec, MetadataReader reader, TypeContext typeContext, ref Exception?exception) { HandleType handleType = typeDefRefOrSpec.HandleType; if (handleType == HandleType.TypeDefinition) { return(typeDefRefOrSpec.ToTypeDefinitionHandle(reader).ResolveTypeDefinition(reader)); } else if (handleType == HandleType.TypeReference) { return(typeDefRefOrSpec.ToTypeReferenceHandle(reader).TryResolveTypeReference(reader, ref exception)); } else if (handleType == HandleType.TypeSpecification) { return(typeDefRefOrSpec.ToTypeSpecificationHandle(reader).TryResolveTypeSignature(reader, typeContext, ref exception)); } else if (handleType == HandleType.ModifiedType) { ModifiedType modifiedType = typeDefRefOrSpec.ToModifiedTypeHandle(reader).GetModifiedType(reader); return(modifiedType.Type.TryResolve(reader, typeContext, ref exception)); } else { throw new BadImageFormatException(); // Expected TypeRef, Def or Spec. } }
// // This is a port of the desktop CLR's RuntimeType.FormatTypeName() routine. This routine is used by various Reflection ToString() methods // to display the name of a type. Do not use for any other purpose as it inherits some pretty quirky desktop behavior. // // The Project N version takes a raw metadata handle rather than a completed type so that it remains robust in the face of missing metadata. // public static String FormatTypeName(this Handle typeDefRefOrSpecHandle, MetadataReader reader, TypeContext typeContext, ReflectionDomain reflectionDomain) { try { // Though we wrap this in a try-catch as a failsafe, this code must still strive to avoid triggering MissingMetadata exceptions // (non-error exceptions are very annoying when debugging.) Exception exception = null; RuntimeType runtimeType = reflectionDomain.TryResolve(reader, typeDefRefOrSpecHandle, typeContext, ref exception); if (runtimeType == null) { return(UnavailableType); } // Because this runtimeType came from a successful TryResolve() call, it is safe to querying the TypeInfo's of the type and its component parts. // If we're wrong, we do have the safety net of a try-catch. return(runtimeType.FormatTypeName()); } catch (Exception) { return(UnavailableType); } }
// // Main routine to resolve a typeDef/Ref/Spec. // internal static RuntimeTypeInfo Resolve(this QTypeDefRefOrSpec typeDefOrRefOrSpec, TypeContext typeContext) { Exception exception = null; RuntimeTypeInfo runtimeType = typeDefOrRefOrSpec.TryResolve(typeContext, ref exception); if (runtimeType == null) { throw exception; } return(runtimeType); }
internal static RuntimeTypeInfo TryResolve(this QTypeDefRefOrSpec typeDefOrRefOrSpec, TypeContext typeContext, ref Exception exception) { if (typeDefOrRefOrSpec.IsNativeFormatMetadataBased) { return(global::Internal.Metadata.NativeFormat.Handle.FromIntToken(typeDefOrRefOrSpec.Handle).TryResolve((global::Internal.Metadata.NativeFormat.MetadataReader)typeDefOrRefOrSpec.Reader, typeContext, ref exception)); } #if ECMA_METADATA_SUPPORT if (typeDefOrRefOrSpec.Reader is global::System.Reflection.Metadata.MetadataReader ecmaReader) { return(global::System.Reflection.Metadata.Ecma335.MetadataTokens.Handle(typeDefOrRefOrSpec.Handle).TryResolve(ecmaReader, typeContext, ref exception)); } #endif throw new BadImageFormatException(); // Expected TypeRef, Def or Spec with MetadataReader }