|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
using System.Collections.Immutable;
using System.Reflection.Metadata;
namespace System.Reflection.TypeLoading.Ecma
{
//
// Base type for an ISignatureTypeProvider that captures pinned types. Note that this only captures custom modifiers
// modifying the Type at the root of the Type expression tree. (This is all that the Reflection api will give you. They're shaped around
// a broken understanding of custom modifiers.) Wrapped types appearing anywhere else must get peeled and thrown away before
// passing it to a type factory method as these methods are completely unprepared to receive these ill-tempered Types.
//
// This situation improved in 8.0 with support for function pointers that have embedded custom modifiers for its parameters.
// This base type is no longer used for FieldInfo, PropertyInfo and ParameterInfo to obtain custom modifiers.
// Instead, "modified types" are created which expose custom modifiers from the corresponding Type.
internal abstract class EcmaWrappedTypeProvider : ISignatureTypeProvider<RoType, TypeContext>
{
private readonly EcmaModule _module;
private readonly EcmaModule _typeProvider;
protected EcmaWrappedTypeProvider(EcmaModule module)
{
_module = module;
_typeProvider = module;
}
//
// ISignatureTypeProvider
//
public RoType GetTypeFromDefinition(MetadataReader reader, TypeDefinitionHandle handle, byte rawTypeKind) => _typeProvider.GetTypeFromDefinition(reader, handle, rawTypeKind);
public RoType GetTypeFromReference(MetadataReader reader, TypeReferenceHandle handle, byte rawTypeKind) => _typeProvider.GetTypeFromReference(reader, handle, rawTypeKind);
public RoType GetTypeFromSpecification(MetadataReader reader, TypeContext genericContext, TypeSpecificationHandle handle, byte rawTypeKind) => _typeProvider.GetTypeFromSpecification(reader, genericContext, handle, rawTypeKind);
public RoType GetSZArrayType(RoType elementType) => _typeProvider.GetSZArrayType(elementType.SkipTypeWrappers());
public RoType GetArrayType(RoType elementType, ArrayShape shape) => _typeProvider.GetArrayType(elementType.SkipTypeWrappers(), shape);
public RoType GetByReferenceType(RoType elementType) => _typeProvider.GetByReferenceType(elementType.SkipTypeWrappers());
public RoType GetPointerType(RoType elementType) => _typeProvider.GetPointerType(elementType.SkipTypeWrappers());
public RoType GetGenericInstantiation(RoType genericType, ImmutableArray<RoType> typeArguments)
{
genericType = genericType.SkipTypeWrappers();
ImmutableArray<RoType> filteredTypeArguments = ImmutableArray<RoType>.Empty;
for (int i = 0; i < typeArguments.Length; i++)
{
filteredTypeArguments = filteredTypeArguments.Add(typeArguments[i].SkipTypeWrappers());
}
return _typeProvider.GetGenericInstantiation(genericType, filteredTypeArguments);
}
public RoType GetGenericTypeParameter(TypeContext genericContext, int index) => _typeProvider.GetGenericTypeParameter(genericContext, index);
public RoType GetGenericMethodParameter(TypeContext genericContext, int index) => _typeProvider.GetGenericMethodParameter(genericContext, index);
public RoType GetFunctionPointerType(MethodSignature<RoType> signature) => _typeProvider.GetFunctionPointerType(signature);
public abstract RoType GetModifiedType(RoType modifier, RoType unmodifiedType, bool isRequired);
public abstract RoType GetPinnedType(RoType elementType);
public RoType GetPrimitiveType(PrimitiveTypeCode typeCode) => _typeProvider.GetPrimitiveType(typeCode);
}
}
|