public MethodSymbols(MetadataToken methodToken)
{
this.method_token = methodToken;
}
internal object GetDefaultValue(MetadataToken token) {
ElementType type;
int constantRid = ConstantTable.GetConstantRowId(token);
if (constantRid == 0) {
return Missing.Value;
}
uint blob = ConstantTable.GetValue(constantRid, out type);
return GetBlobValue(blob, type);
}
[System.Security.SecuritySafeCritical] // auto-generated
public override FieldInfo ResolveField(int metadataToken, Type[] genericTypeArguments, Type[] genericMethodArguments)
{
MetadataToken tk = new MetadataToken(metadataToken);
if (!MetadataImport.IsValidToken(tk))
throw new ArgumentOutOfRangeException(nameof(metadataToken),
Environment.GetResourceString("Argument_InvalidToken", tk, this));
RuntimeTypeHandle[] typeArgs = ConvertToTypeHandleArray(genericTypeArguments);
RuntimeTypeHandle[] methodArgs = ConvertToTypeHandleArray(genericMethodArguments);
try
{
IRuntimeFieldInfo fieldHandle = null;
if (!tk.IsFieldDef)
{
if (!tk.IsMemberRef)
throw new ArgumentException(Environment.GetResourceString("Argument_ResolveField", tk, this),
nameof(metadataToken));
unsafe
{
ConstArray sig = MetadataImport.GetMemberRefProps(tk);
if (*(MdSigCallingConvention*)sig.Signature.ToPointer() != MdSigCallingConvention.Field)
throw new ArgumentException(Environment.GetResourceString("Argument_ResolveField", tk, this),
nameof(metadataToken));
}
fieldHandle = ModuleHandle.ResolveFieldHandleInternal(GetNativeHandle(), tk, typeArgs, methodArgs);
}
fieldHandle = ModuleHandle.ResolveFieldHandleInternal(GetNativeHandle(), metadataToken, typeArgs, methodArgs);
RuntimeType declaringType = RuntimeFieldHandle.GetApproxDeclaringType(fieldHandle.Value);
if (declaringType.IsGenericType || declaringType.IsArray)
{
int tkDeclaringType = ModuleHandle.GetMetadataImport(GetNativeHandle()).GetParentToken(metadataToken);
declaringType = (RuntimeType)ResolveType(tkDeclaringType, genericTypeArguments, genericMethodArguments);
}
return System.RuntimeType.GetFieldInfo(declaringType, fieldHandle);
}
catch(MissingFieldException)
{
return ResolveLiteralField(tk, genericTypeArguments, genericMethodArguments);
}
catch (BadImageFormatException e)
{
throw new ArgumentException(Environment.GetResourceString("Argument_BadImageFormatExceptionResolve"), e);
}
}
[System.Security.SecuritySafeCritical] // auto-generated
public override MemberInfo ResolveMember(int metadataToken, Type[] genericTypeArguments, Type[] genericMethodArguments)
{
MetadataToken tk = new MetadataToken(metadataToken);
if (tk.IsProperty)
throw new ArgumentException(Environment.GetResourceString("InvalidOperation_PropertyInfoNotAvailable"));
if (tk.IsEvent)
throw new ArgumentException(Environment.GetResourceString("InvalidOperation_EventInfoNotAvailable"));
if (tk.IsMethodSpec || tk.IsMethodDef)
return ResolveMethod(metadataToken, genericTypeArguments, genericMethodArguments);
if (tk.IsFieldDef)
return ResolveField(metadataToken, genericTypeArguments, genericMethodArguments);
if (tk.IsTypeRef || tk.IsTypeDef || tk.IsTypeSpec)
return ResolveType(metadataToken, genericTypeArguments, genericMethodArguments);
if (tk.IsMemberRef)
{
if (!MetadataImport.IsValidToken(tk))
throw new ArgumentOutOfRangeException(nameof(metadataToken),
Environment.GetResourceString("Argument_InvalidToken", tk, this));
ConstArray sig = MetadataImport.GetMemberRefProps(tk);
unsafe
{
if (*(MdSigCallingConvention*)sig.Signature.ToPointer() == MdSigCallingConvention.Field)
{
return ResolveField(tk, genericTypeArguments, genericMethodArguments);
}
else
{
return ResolveMethod(tk, genericTypeArguments, genericMethodArguments);
}
}
}
throw new ArgumentException(Environment.GetResourceString("Argument_ResolveMember", tk, this),
nameof(metadataToken));
}
[System.Security.SecurityCritical] // auto-generated
private unsafe static bool FilterCustomAttributeRecord(
CustomAttributeRecord caRecord,
MetadataImport scope,
ref Assembly lastAptcaOkAssembly,
RuntimeModule decoratedModule,
MetadataToken decoratedToken,
RuntimeType attributeFilterType,
bool mustBeInheritable,
object[] attributes,
IList derivedAttributes,
out RuntimeType attributeType,
out IRuntimeMethodInfo ctor,
out bool ctorHasParameters,
out bool isVarArg)
{
ctor = null;
attributeType = null;
ctorHasParameters = false;
isVarArg = false;
IntPtr blobStart = caRecord.blob.Signature;
IntPtr blobEnd = (IntPtr)((byte*)blobStart + caRecord.blob.Length);
#if FEATURE_LEGACYNETCF
if (CompatibilitySwitches.IsAppEarlierThanWindowsPhone8) {
try
{
// Resolve attribute type from ctor parent token found in decorated decoratedModule scope
attributeType = decoratedModule.ResolveType(scope.GetParentToken(caRecord.tkCtor), null, null) as RuntimeType;
}
catch(Exception)
{
return false;
}
}
else
#endif
// Resolve attribute type from ctor parent token found in decorated decoratedModule scope
attributeType = decoratedModule.ResolveType(scope.GetParentToken(caRecord.tkCtor), null, null) as RuntimeType;
// Test attribute type against user provided attribute type filter
if (!(attributeFilterType.IsAssignableFrom(attributeType)))
return false;
// Ensure if attribute type must be inheritable that it is inhertiable
// Ensure that to consider a duplicate attribute type AllowMultiple is true
if (!AttributeUsageCheck(attributeType, mustBeInheritable, attributes, derivedAttributes))
return false;
// Windows Runtime attributes aren't real types - they exist to be read as metadata only, and as such
// should be filtered out of the GetCustomAttributes path.
if ((attributeType.Attributes & TypeAttributes.WindowsRuntime) == TypeAttributes.WindowsRuntime)
{
return false;
}
#if FEATURE_APTCA
// APTCA checks
RuntimeAssembly attributeAssembly = (RuntimeAssembly)attributeType.Assembly;
RuntimeAssembly decoratedModuleAssembly = (RuntimeAssembly)decoratedModule.Assembly;
if (attributeAssembly != lastAptcaOkAssembly &&
!RuntimeAssembly.AptcaCheck(attributeAssembly, decoratedModuleAssembly))
return false;
// Cache last successful APTCA check (optimization)
lastAptcaOkAssembly = decoratedModuleAssembly;
#endif // FEATURE_APTCA
// Resolve the attribute ctor
ConstArray ctorSig = scope.GetMethodSignature(caRecord.tkCtor);
isVarArg = (ctorSig[0] & 0x05) != 0;
ctorHasParameters = ctorSig[1] != 0;
if (ctorHasParameters)
{
// Resolve method ctor token found in decorated decoratedModule scope
ctor = ModuleHandle.ResolveMethodHandleInternal(decoratedModule.GetNativeHandle(), caRecord.tkCtor);
}
else
{
// Resolve method ctor token from decorated decoratedModule scope
ctor = attributeType.GetTypeHandleInternal().GetDefaultConstructor();
if (ctor == null && !attributeType.IsValueType)
throw new MissingMethodException(".ctor");
}
// Visibility checks
MetadataToken tkParent = new MetadataToken();
if (decoratedToken.IsParamDef)
{
tkParent = new MetadataToken(scope.GetParentToken(decoratedToken));
tkParent = new MetadataToken(scope.GetParentToken(tkParent));
}
else if (decoratedToken.IsMethodDef || decoratedToken.IsProperty || decoratedToken.IsEvent || decoratedToken.IsFieldDef)
{
tkParent = new MetadataToken(scope.GetParentToken(decoratedToken));
}
else if (decoratedToken.IsTypeDef)
{
tkParent = decoratedToken;
}
else if (decoratedToken.IsGenericPar)
{
tkParent = new MetadataToken(scope.GetParentToken(decoratedToken));
// decoratedToken is a generic parameter on a method. Get the declaring Type of the method.
if (tkParent.IsMethodDef)
tkParent = new MetadataToken(scope.GetParentToken(tkParent));
}
else
{
// We need to relax this when we add support for other types of decorated tokens.
Contract.Assert(decoratedToken.IsModule || decoratedToken.IsAssembly,
"The decoratedToken must be either an assembly, a module, a type, or a member.");
}
// If the attribute is on a type, member, or parameter we check access against the (declaring) type,
// otherwise we check access against the module.
RuntimeTypeHandle parentTypeHandle = tkParent.IsTypeDef ?
decoratedModule.ModuleHandle.ResolveTypeHandle(tkParent) :
new RuntimeTypeHandle();
return RuntimeMethodHandle.IsCAVisibleFromDecoratedType(attributeType.TypeHandle, ctor, parentTypeHandle, decoratedModule);
}
[System.Security.SecuritySafeCritical] // auto-generated
public override MethodBase ResolveMethod(int metadataToken, Type[] genericTypeArguments, Type[] genericMethodArguments)
{
MetadataToken tk = new MetadataToken(metadataToken);
if (!MetadataImport.IsValidToken(tk))
throw new ArgumentOutOfRangeException(nameof(metadataToken),
Environment.GetResourceString("Argument_InvalidToken", tk, this));
RuntimeTypeHandle[] typeArgs = ConvertToTypeHandleArray(genericTypeArguments);
RuntimeTypeHandle[] methodArgs = ConvertToTypeHandleArray(genericMethodArguments);
try
{
if (!tk.IsMethodDef && !tk.IsMethodSpec)
{
if (!tk.IsMemberRef)
throw new ArgumentException(Environment.GetResourceString("Argument_ResolveMethod", tk, this),
nameof(metadataToken));
unsafe
{
ConstArray sig = MetadataImport.GetMemberRefProps(tk);
if (*(MdSigCallingConvention*)sig.Signature.ToPointer() == MdSigCallingConvention.Field)
throw new ArgumentException(Environment.GetResourceString("Argument_ResolveMethod", tk, this),
nameof(metadataToken));
}
}
IRuntimeMethodInfo methodHandle = ModuleHandle.ResolveMethodHandleInternal(GetNativeHandle(), tk, typeArgs, methodArgs);
Type declaringType = RuntimeMethodHandle.GetDeclaringType(methodHandle);
if (declaringType.IsGenericType || declaringType.IsArray)
{
MetadataToken tkDeclaringType = new MetadataToken(MetadataImport.GetParentToken(tk));
if (tk.IsMethodSpec)
tkDeclaringType = new MetadataToken(MetadataImport.GetParentToken(tkDeclaringType));
declaringType = ResolveType(tkDeclaringType, genericTypeArguments, genericMethodArguments);
}
return System.RuntimeType.GetMethodBase(declaringType as RuntimeType, methodHandle);
}
catch (BadImageFormatException e)
{
throw new ArgumentException(Environment.GetResourceString("Argument_BadImageFormatExceptionResolve"), e);
}
}
public override void GetTypeRefProps(
TypeReferenceHandle typeRef,
out string name,
out string @namespace,
out MetadataToken resolutionScope)
{
base.GetTypeRefProps(typeRef, out name, out @namespace, out resolutionScope);
// TODO (tomat): disable the warning temporarily until we move this code to the metadata reader
#pragma warning disable 618 // obsolete warning reported when RowIds are used
uint assemblyRefOffset;
string clrName, clrNamespace;
if (WinRTProjectedTypes.ResolveWinRTTypeReference(name, @namespace, out clrName, out clrNamespace, out assemblyRefOffset))
{
name = clrName;
@namespace = clrNamespace;
uint assemblyRefRid = this.winMdStartIndex + assemblyRefOffset + 1;
resolutionScope = AssemblyReferenceHandle.FromRowId(assemblyRefRid);
}
else if (GetTypeRefTreatment(typeRef) != TypeRefTreatment.None)
{
uint assemblyRefRid = this.winMdStartIndex + (uint)WinMdAssembliesOffsets.SystemRuntime + 1;
resolutionScope = AssemblyReferenceHandle.FromRowId(assemblyRefRid);
}
#pragma warning restore 618 // obsolete warning reported when RowIds are used
}
public ConstArray GetMethodSignature(MetadataToken token)
{
if (token.IsMemberRef)
{
return this.GetMemberRefProps((int) token);
}
return this.GetSigOfMethodDef((int) token);
}
private TypeDefTreatment GetTypeDefTreatment(
TypeHandle typeDef,
TypeAttributes flags,
string name,
string namespaceName,
MetadataToken extends)
{
TypeDefTreatment treatment;
// Does the type def have the WindowsRuntime bit set?
if (flags.IsWindowsRuntime())
{
if (scenario == WinMDScenario.NormalWinMD)
{
treatment = WinRTProjectedTypes.GetTypeDefinitionTreatment(name, namespaceName);
if (treatment != TypeDefTreatment.None)
{
return treatment;
}
// Is this an attribute?
if (extends.HandleType == HandleType.TypeReference && GetTypeRefTreatment((TypeReferenceHandle)extends) == TypeRefTreatment.SystemAttribute)
{
treatment = TypeDefTreatment.NormalAttribute;
}
else
{
treatment = TypeDefTreatment.NormalNonAttribute;
}
}
else if (scenario == WinMDScenario.WinMDExp && !flags.IsNested() && flags.IsPublic() && flags.IsSpecialName())
{
treatment = TypeDefTreatment.PrefixWinRTName;
}
else
{
treatment = TypeDefTreatment.None;
}
// Scan through Custom Attributes on type, looking for interesting bits. We only
// need to do this for RuntimeClasses
if (treatment == TypeDefTreatment.PrefixWinRTName || treatment == TypeDefTreatment.NormalNonAttribute)
{
if (!flags.IsInterface() && HasAttribute(typeDef, "Windows.UI.Xaml", "TreatAsAbstractComposableClassAttribute"))
{
treatment |= TypeDefTreatment.MarkAbstractFlag;
}
}
}
else if (this.scenario == WinMDScenario.WinMDExp && IsClrImplementationType(name, flags))
{
treatment = TypeDefTreatment.UnmangleWinRTName;
}
else
{
treatment = TypeDefTreatment.None;
}
return treatment;
}
// TODO (tomat): disable the warning temporarily until we move this code to the metadata reader
#pragma warning disable 618
private bool HasAttribute(MetadataToken token, string namespaceName, string typeName)
{
foreach (var caHandle in peFileReader.GetCustomAttributes(token))
{
StringHandle namespaceHandle, nameHandle;
if (peFileReader.GetCustomAttribute(caHandle).GetFullTypeName(out namespaceHandle, out nameHandle) &&
peFileReader.StringStream.CheckForText(namespaceHandle, namespaceName) &&
peFileReader.StringStream.CheckForText(nameHandle, typeName))
{
return true;
}
}
return false;
}
private static RuntimeMethodInfo?AssignAssociates(
int tkMethod,
RuntimeType declaredType,
RuntimeType reflectedType)
{
if (MetadataToken.IsNullToken(tkMethod))
{
return(null);
}
Debug.Assert(declaredType != null);
Debug.Assert(reflectedType != null);
bool isInherited = declaredType != reflectedType;
IntPtr[]? genericArgumentHandles = null;
int genericArgumentCount = 0;
RuntimeType[] genericArguments = declaredType.GetTypeHandleInternal().GetInstantiationInternal();
if (genericArguments != null)
{
genericArgumentCount = genericArguments.Length;
genericArgumentHandles = new IntPtr[genericArguments.Length];
for (int i = 0; i < genericArguments.Length; i++)
{
genericArgumentHandles[i] = genericArguments[i].GetTypeHandleInternal().Value;
}
}
RuntimeMethodHandleInternal associateMethodHandle = ModuleHandle.ResolveMethodHandleInternal(RuntimeTypeHandle.GetModule(declaredType), tkMethod, genericArgumentHandles, genericArgumentCount, null, 0);
Debug.Assert(!associateMethodHandle.IsNullHandle(), "Failed to resolve associateRecord methodDef token");
if (isInherited)
{
MethodAttributes methAttr = RuntimeMethodHandle.GetAttributes(associateMethodHandle);
// ECMA MethodSemantics: "All methods for a given Property or Event shall have the same accessibility
// (ie the MemberAccessMask subfield of their Flags row) and cannot be CompilerControlled [CLS]"
// Consequently, a property may be composed of public and private methods. If the declared type !=
// the reflected type, the private methods should not be exposed. Note that this implies that the
// identity of a property includes it's reflected type.
if ((methAttr & MethodAttributes.MemberAccessMask) == MethodAttributes.Private)
{
return(null);
}
// Note this is the first time the property was encountered walking from the most derived class
// towards the base class. It would seem to follow that any associated methods would not
// be overriden -- but this is not necessarily true. A more derived class may have overriden a
// virtual method associated with a property in a base class without associating the override with
// the same or any property in the derived class.
if ((methAttr & MethodAttributes.Virtual) != 0)
{
bool declaringTypeIsClass =
(RuntimeTypeHandle.GetAttributes(declaredType) & TypeAttributes.ClassSemanticsMask) == TypeAttributes.Class;
// It makes no sense to search for a virtual override of a method declared on an interface.
if (declaringTypeIsClass)
{
int slot = RuntimeMethodHandle.GetSlot(associateMethodHandle);
// Find the override visible from the reflected type
associateMethodHandle = RuntimeTypeHandle.GetMethodAt(reflectedType, slot);
}
}
}
RuntimeMethodInfo?associateMethod =
RuntimeType.GetMethodBase(reflectedType, associateMethodHandle) as RuntimeMethodInfo;
// suppose a property was mapped to a method not in the derivation hierarchy of the reflectedTypeHandle
return(associateMethod ?? reflectedType.Module.ResolveMethod(tkMethod, null, null) as RuntimeMethodInfo);
}
public override FieldInfo?ResolveField(int metadataToken, Type[]?genericTypeArguments, Type[]?genericMethodArguments)
{
try
{
MetadataToken tk = new MetadataToken(metadataToken);
if (!MetadataImport.IsValidToken(tk))
{
throw new ArgumentOutOfRangeException(nameof(metadataToken),
SR.Format(SR.Argument_InvalidToken, tk, this));
}
RuntimeTypeHandle[]? typeArgs = null;
RuntimeTypeHandle[]? methodArgs = null;
if (genericTypeArguments?.Length > 0)
{
typeArgs = ConvertToTypeHandleArray(genericTypeArguments);
}
if (genericMethodArguments?.Length > 0)
{
methodArgs = ConvertToTypeHandleArray(genericMethodArguments);
}
ModuleHandle moduleHandle = new ModuleHandle(this);
if (!tk.IsFieldDef)
{
if (!tk.IsMemberRef)
{
throw new ArgumentException(SR.Format(SR.Argument_ResolveField, tk, this),
nameof(metadataToken));
}
unsafe
{
ConstArray sig = MetadataImport.GetMemberRefProps(tk);
if (*(MdSigCallingConvention *)sig.Signature != MdSigCallingConvention.Field)
{
throw new ArgumentException(SR.Format(SR.Argument_ResolveField, tk, this),
nameof(metadataToken));
}
}
}
IRuntimeFieldInfo fieldHandle = moduleHandle.ResolveFieldHandle(metadataToken, typeArgs, methodArgs).GetRuntimeFieldInfo();
RuntimeType declaringType = RuntimeFieldHandle.GetApproxDeclaringType(fieldHandle.Value);
if (declaringType.IsGenericType || declaringType.IsArray)
{
int tkDeclaringType = ModuleHandle.GetMetadataImport(this).GetParentToken(metadataToken);
declaringType = (RuntimeType)ResolveType(tkDeclaringType, genericTypeArguments, genericMethodArguments);
}
return(RuntimeType.GetFieldInfo(declaringType, fieldHandle));
}
catch (MissingFieldException)
{
return(ResolveLiteralField(metadataToken, genericTypeArguments, genericMethodArguments));
}
catch (BadImageFormatException e)
{
throw new ArgumentException(SR.Argument_BadImageFormatExceptionResolve, e);
}
}
private static partial void GetForwardedType(QCallAssembly assembly, MetadataToken mdtExternalType, ObjectHandleOnStack type);
public override MemberInfo?ResolveMember(
int metadataToken,
Type[]?genericTypeArguments,
Type[]?genericMethodArguments
)
{
MetadataToken tk = new MetadataToken(metadataToken);
if (tk.IsProperty)
{
throw new ArgumentException(SR.InvalidOperation_PropertyInfoNotAvailable);
}
if (tk.IsEvent)
{
throw new ArgumentException(SR.InvalidOperation_EventInfoNotAvailable);
}
if (tk.IsMethodSpec || tk.IsMethodDef)
{
return(ResolveMethod(metadataToken, genericTypeArguments, genericMethodArguments));
}
if (tk.IsFieldDef)
{
return(ResolveField(metadataToken, genericTypeArguments, genericMethodArguments));
}
if (tk.IsTypeRef || tk.IsTypeDef || tk.IsTypeSpec)
{
return(ResolveType(metadataToken, genericTypeArguments, genericMethodArguments));
}
if (tk.IsMemberRef)
{
if (!MetadataImport.IsValidToken(tk))
{
throw new ArgumentOutOfRangeException(
nameof(metadataToken),
SR.Format(SR.Argument_InvalidToken, tk, this)
);
}
ConstArray sig = MetadataImport.GetMemberRefProps(tk);
unsafe
{
if (*(MdSigCallingConvention *)sig.Signature == MdSigCallingConvention.Field)
{
return(ResolveField(tk, genericTypeArguments, genericMethodArguments));
}
else
{
return(ResolveMethod(tk, genericTypeArguments, genericMethodArguments));
}
}
}
throw new ArgumentException(
SR.Format(SR.Argument_ResolveMember, tk, this),
nameof(metadataToken)
);
}
public override void GetTypeDefProps(
TypeHandle typeDef,
out string name,
out string namespaceName,
out TypeAttributes flags,
out MetadataToken extends)
{
base.GetTypeDefProps(typeDef,
out name,
out namespaceName,
out flags,
out extends);
TypeDefTreatment treatment =
GetTypeDefTreatment(typeDef, flags, name, namespaceName, extends);
switch (treatment & TypeDefTreatment.TreatmentMask)
{
case TypeDefTreatment.None:
break;
case TypeDefTreatment.NormalNonAttribute:
flags |= TypeAttributes.WindowsRuntime | TypeAttributes.Import;
break;
case TypeDefTreatment.NormalAttribute:
flags |= TypeAttributes.WindowsRuntime | TypeAttributes.Sealed;
break;
case TypeDefTreatment.UnmangleWinRTName:
name = name.Substring(clrPrefix.Length);
flags |= TypeAttributes.Public;
break;
case TypeDefTreatment.PrefixWinRTName:
name = winRtPrefix + name;
flags &= TypeAttributes.Public;
flags |= TypeAttributes.Import;
break;
case TypeDefTreatment.RedirectedToCLRType:
flags &= ~TypeAttributes.Public;
flags |= TypeAttributes.Import;
break;
case TypeDefTreatment.RedirectedToCLRAttribute:
flags &= ~TypeAttributes.Public;
break;
}
if (treatment.HasFlag(TypeDefTreatment.MarkAbstractFlag))
{
flags |= TypeAttributes.Abstract;
}
if (treatment.HasFlag(TypeDefTreatment.MarkInternalFlag))
{
flags &= ~TypeAttributes.Public;
}
}
public FieldInfo ResolveField(int metadataToken, Type[] genericTypeArguments, Type[] genericMethodArguments)
{
MetadataToken tk = new MetadataToken(metadataToken);
if (!MetadataImport.IsValidToken(tk))
throw new ArgumentOutOfRangeException("metadataToken",
String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Argument_InvalidToken", tk, this)));
RuntimeTypeHandle[] typeArgs = ConvertToTypeHandleArray(genericTypeArguments);
RuntimeTypeHandle[] methodArgs = ConvertToTypeHandleArray(genericMethodArguments);
try
{
RuntimeFieldHandle fieldHandle = new RuntimeFieldHandle();
if (!tk.IsFieldDef)
{
if (!tk.IsMemberRef)
throw new ArgumentException("metadataToken",
String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Argument_ResolveField"), tk, this));
unsafe
{
ConstArray sig = MetadataImport.GetMemberRefProps(tk);
if (*(CorCallingConvention*)sig.Signature.ToPointer() != CorCallingConvention.Field)
throw new ArgumentException("metadataToken",
String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Argument_ResolveField"), tk, this));
}
fieldHandle = GetModuleHandle().ResolveFieldHandle(tk, typeArgs, methodArgs);
}
fieldHandle = GetModuleHandle().ResolveFieldHandle(metadataToken, typeArgs, methodArgs);
Type declaringType = fieldHandle.GetApproxDeclaringType().GetRuntimeType();
if (declaringType.IsGenericType || declaringType.IsArray)
{
int tkDeclaringType = GetModuleHandle().GetMetadataImport().GetParentToken(metadataToken);
declaringType = ResolveType(tkDeclaringType, genericTypeArguments, genericMethodArguments);
}
return System.RuntimeType.GetFieldInfo(declaringType.GetTypeHandleInternal(), fieldHandle);
}
catch(MissingFieldException)
{
return ResolveLiteralField(tk, genericTypeArguments, genericMethodArguments);
}
catch (BadImageFormatException e)
{
throw new ArgumentException(Environment.GetResourceString("Argument_BadImageFormatExceptionResolve"), e);
}
}
public bool IsValidToken(MetadataToken token)
{
return m_import.IsValidToken(token);
}
[System.Security.SecurityCritical] // auto-generated
public ConstArray GetMethodSignature(MetadataToken token)
{
if (token.IsMemberRef)
return GetMemberRefProps(token);
return GetSigOfMethodDef(token);
}
internal int GetFieldMarshalRowId(MetadataToken token)
{
int foundRowNumber = Table.BinarySearchReference(
NumberOfRows,
RowSize,
ParentOffset,
HasFieldMarshalTag.ConvertToTag(token),
IsHasFieldMarshalRefSizeSmall
);
return foundRowNumber + 1;
}
[System.Security.SecuritySafeCritical] // auto-generated
public override byte[] ResolveSignature(int metadataToken)
{
MetadataToken tk = new MetadataToken(metadataToken);
if (!MetadataImport.IsValidToken(tk))
throw new ArgumentOutOfRangeException(nameof(metadataToken),
Environment.GetResourceString("Argument_InvalidToken", tk, this));
if (!tk.IsMemberRef && !tk.IsMethodDef && !tk.IsTypeSpec && !tk.IsSignature && !tk.IsFieldDef)
throw new ArgumentException(Environment.GetResourceString("Argument_InvalidToken", tk, this),
nameof(metadataToken));
ConstArray signature;
if (tk.IsMemberRef)
signature = MetadataImport.GetMemberRefProps(metadataToken);
else
signature = MetadataImport.GetSignatureFromToken(metadataToken);
byte[] sig = new byte[signature.Length];
for (int i = 0; i < signature.Length; i++)
sig[i] = signature[i];
return sig;
}
internal int GetConstantRowId(MetadataToken parentToken)
{
int foundRowNumber = Table.BinarySearchReference(
NumberOfRows,
RowSize,
ParentOffset,
HasConstantTag.ConvertToTag(parentToken),
IsHasConstantRefSizeSmall
);
return foundRowNumber + 1;
}
[System.Security.SecurityCritical] // auto-generated
private FieldInfo ResolveLiteralField(int metadataToken, Type[] genericTypeArguments, Type[] genericMethodArguments)
{
MetadataToken tk = new MetadataToken(metadataToken);
if (!MetadataImport.IsValidToken(tk) || !tk.IsFieldDef)
throw new ArgumentOutOfRangeException(nameof(metadataToken),
String.Format(CultureInfo.CurrentUICulture, Environment.GetResourceString("Argument_InvalidToken", tk, this)));
int tkDeclaringType;
string fieldName;
fieldName = MetadataImport.GetName(tk).ToString();
tkDeclaringType = MetadataImport.GetParentToken(tk);
Type declaringType = ResolveType(tkDeclaringType, genericTypeArguments, genericMethodArguments);
declaringType.GetFields();
try
{
return declaringType.GetField(fieldName,
BindingFlags.Static | BindingFlags.Instance |
BindingFlags.Public | BindingFlags.NonPublic |
BindingFlags.DeclaredOnly);
}
catch
{
throw new ArgumentException(Environment.GetResourceString("Argument_ResolveField", tk, this), nameof(metadataToken));
}
}
internal int FindCustomAttributesForToken(MetadataToken token, out int customAttributeCount)
{
return BinarySearchTag(HasCustomAttributeTag.ConvertToTag(token), out customAttributeCount);
}
[System.Security.SecuritySafeCritical] // auto-generated
public override Type ResolveType(int metadataToken, Type[] genericTypeArguments, Type[] genericMethodArguments)
{
MetadataToken tk = new MetadataToken(metadataToken);
if (tk.IsGlobalTypeDefToken)
throw new ArgumentException(Environment.GetResourceString("Argument_ResolveModuleType", tk), nameof(metadataToken));
if (!MetadataImport.IsValidToken(tk))
throw new ArgumentOutOfRangeException(nameof(metadataToken),
Environment.GetResourceString("Argument_InvalidToken", tk, this));
if (!tk.IsTypeDef && !tk.IsTypeSpec && !tk.IsTypeRef)
throw new ArgumentException(Environment.GetResourceString("Argument_ResolveType", tk, this), nameof(metadataToken));
RuntimeTypeHandle[] typeArgs = ConvertToTypeHandleArray(genericTypeArguments);
RuntimeTypeHandle[] methodArgs = ConvertToTypeHandleArray(genericMethodArguments);
try
{
Type t = GetModuleHandle().ResolveTypeHandle(metadataToken, typeArgs, methodArgs).GetRuntimeType();
if (t == null)
throw new ArgumentException(Environment.GetResourceString("Argument_ResolveType", tk, this), nameof(metadataToken));
return t;
}
catch (BadImageFormatException e)
{
throw new ArgumentException(Environment.GetResourceString("Argument_BadImageFormatExceptionResolve"), e);
}
}
internal int FindSecurityAttributesForToken(MetadataToken token, out int securityAttributeCount)
{
uint searchCodedTag = HasDeclSecurityTag.ConvertToTag(token);
return BinarySearchTag(searchCodedTag, out securityAttributeCount);
}
[System.Security.SecuritySafeCritical] // auto-generated
public override string ResolveString(int metadataToken)
{
MetadataToken tk = new MetadataToken(metadataToken);
if (!tk.IsString)
throw new ArgumentException(
String.Format(CultureInfo.CurrentUICulture, Environment.GetResourceString("Argument_ResolveString"), metadataToken, ToString()));
if (!MetadataImport.IsValidToken(tk))
throw new ArgumentOutOfRangeException(nameof(metadataToken),
String.Format(CultureInfo.CurrentUICulture, Environment.GetResourceString("Argument_InvalidToken", tk, this)));
string str = MetadataImport.GetUserString(metadataToken);
if (str == null)
throw new ArgumentException(
String.Format(CultureInfo.CurrentUICulture, Environment.GetResourceString("Argument_ResolveString"), metadataToken, ToString()));
return str;
}
internal unsafe static bool FilterCustomAttributeRecord(
CustomAttributeRecord caRecord, MetadataImport scope, ref Assembly lastAptcaOkAssembly,
Module decoratedModule, MetadataToken decoratedToken, RuntimeType attributeFilterType, bool mustBeInheritable,
object[] attributes, IList derivedAttributes,
out RuntimeType attributeType, out RuntimeMethodHandle ctor, out bool ctorHasParameters, out bool isVarArg)
{
ctor = new RuntimeMethodHandle();
attributeType = null;
ctorHasParameters = false;
isVarArg = false;
IntPtr blobStart = caRecord.blob.Signature;
IntPtr blobEnd = (IntPtr)((byte*)blobStart + caRecord.blob.Length);
// Resolve attribute type from ctor parent token found in decorated decoratedModule scope
attributeType = decoratedModule.ResolveType(scope.GetParentToken(caRecord.tkCtor), null, null) as RuntimeType;
// Test attribute type against user provided attribute type filter
if (!(attributeFilterType.IsAssignableFrom(attributeType)))
return false;
if (!AttributeUsageCheck(attributeType, mustBeInheritable, attributes, derivedAttributes))
return false;
// APTCA checks
if (attributeType.Assembly != lastAptcaOkAssembly &&
!attributeType.Assembly.AptcaCheck(decoratedModule.Assembly))
return false;
// Cache last successful APTCA check (optimization)
lastAptcaOkAssembly = decoratedModule.Assembly;
// Resolve the attribute ctor
ConstArray ctorSig = scope.GetMethodSignature(caRecord.tkCtor);
isVarArg = (ctorSig[0] & 0x05) != 0;
ctorHasParameters = ctorSig[1] != 0;
if (ctorHasParameters)
{
// Resolve method ctor token found in decorated decoratedModule scope
ctor = decoratedModule.ModuleHandle.ResolveMethodHandle(caRecord.tkCtor);
}
else
{
// Resolve method ctor token from decorated decoratedModule scope
ctor = attributeType.GetTypeHandleInternal().GetDefaultConstructor();
if (ctor.IsNullHandle() && !attributeType.IsValueType)
throw new MissingMethodException(".ctor");
}
// Visibility checks
if (ctor.IsNullHandle())
{
if (!attributeType.IsVisible && !attributeType.TypeHandle.IsVisibleFromModule(decoratedModule.ModuleHandle))
return false;
return true;
}
if (ctor.IsVisibleFromModule(decoratedModule))
return true;
MetadataToken tkParent = new MetadataToken();
if (decoratedToken.IsParamDef)
{
tkParent = new MetadataToken(scope.GetParentToken(decoratedToken));
tkParent = new MetadataToken(scope.GetParentToken(tkParent));
}
else if (decoratedToken.IsMethodDef || decoratedToken.IsProperty || decoratedToken.IsEvent || decoratedToken.IsFieldDef)
{
tkParent = new MetadataToken(scope.GetParentToken(decoratedToken));
}
else if (decoratedToken.IsTypeDef)
{
tkParent = decoratedToken;
}
if (tkParent.IsTypeDef)
return ctor.IsVisibleFromType(decoratedModule.ModuleHandle.ResolveTypeHandle(tkParent));
return false;
}
internal bool IsValidToken(MetadataToken token) {
int tableIndex = (int)token.RecordType;
if (tableIndex < _tableRowCounts.Length) {
return token.Rid <= _tableRowCounts[tableIndex];
}
switch (tableIndex) {
case (int)MetadataTokenType.String >> 24: return token.Rid < _stringStream.Length;
case (int)MetadataTokenType.Name >> 24: return _userStringStream != null && token.Rid < _userStringStream.Length;
}
return false;
}
internal static unsafe bool FilterCustomAttributeRecord(CustomAttributeRecord caRecord, MetadataImport scope, ref Assembly lastAptcaOkAssembly, Module decoratedModule, MetadataToken decoratedToken, RuntimeType attributeFilterType, bool mustBeInheritable, object[] attributes, IList derivedAttributes, out RuntimeType attributeType, out RuntimeMethodHandle ctor, out bool ctorHasParameters, out bool isVarArg)
{
ctor = new RuntimeMethodHandle();
attributeType = null;
ctorHasParameters = false;
isVarArg = false;
IntPtr ptr1 = (IntPtr) (((void*) caRecord.blob.Signature) + caRecord.blob.Length);
attributeType = decoratedModule.ResolveType(scope.GetParentToken((int) caRecord.tkCtor), null, null) as RuntimeType;
if (!attributeFilterType.IsAssignableFrom(attributeType))
{
return false;
}
if (!AttributeUsageCheck(attributeType, mustBeInheritable, attributes, derivedAttributes))
{
return false;
}
if ((attributeType.Assembly != lastAptcaOkAssembly) && !attributeType.Assembly.AptcaCheck(decoratedModule.Assembly))
{
return false;
}
lastAptcaOkAssembly = decoratedModule.Assembly;
ConstArray methodSignature = scope.GetMethodSignature(caRecord.tkCtor);
isVarArg = (methodSignature[0] & 5) != 0;
ctorHasParameters = methodSignature[1] != 0;
if (ctorHasParameters)
{
ctor = decoratedModule.ModuleHandle.ResolveMethodHandle((int) caRecord.tkCtor);
}
else
{
ctor = attributeType.GetTypeHandleInternal().GetDefaultConstructor();
if (ctor.IsNullHandle() && !attributeType.IsValueType)
{
throw new MissingMethodException(".ctor");
}
}
if (ctor.IsNullHandle())
{
if (!attributeType.IsVisible && !attributeType.TypeHandle.IsVisibleFromModule(decoratedModule.ModuleHandle))
{
return false;
}
return true;
}
if (ctor.IsVisibleFromModule(decoratedModule))
{
return true;
}
MetadataToken token = new MetadataToken();
if (decoratedToken.IsParamDef)
{
token = new MetadataToken(scope.GetParentToken((int) decoratedToken));
token = new MetadataToken(scope.GetParentToken((int) token));
}
else if ((decoratedToken.IsMethodDef || decoratedToken.IsProperty) || (decoratedToken.IsEvent || decoratedToken.IsFieldDef))
{
token = new MetadataToken(scope.GetParentToken((int) decoratedToken));
}
else if (decoratedToken.IsTypeDef)
{
token = decoratedToken;
}
return (token.IsTypeDef && ctor.IsVisibleFromType(decoratedModule.ModuleHandle.ResolveTypeHandle((int) token)));
}
internal EnumerationIndirection GetEnumeratorRange(MetadataTokenType type, MetadataToken parent, out int startRid, out int count) {
Debug.Assert(IsValidToken(parent));
switch (type) {
case MetadataTokenType.MethodDef:
if (parent.IsNull) {
count = MethodTable.NumberOfRows;
startRid = 1;
} else {
Debug.Assert(parent.IsTypeDef);
startRid = GetMethodRange(parent.Rid, out count);
}
return UseParamPtrTable ? EnumerationIndirection.Method : EnumerationIndirection.None;
case MetadataTokenType.Property:
if (parent.IsNull) {
count = PropertyTable.NumberOfRows;
startRid = 1;
} else {
Debug.Assert(parent.IsTypeDef);
startRid = GetPropertyRange(parent.Rid, out count);
}
return UsePropertyPtrTable ? EnumerationIndirection.Property : EnumerationIndirection.None;
case MetadataTokenType.Event:
if (parent.IsNull) {
count = EventTable.NumberOfRows;
startRid = 1;
} else {
Debug.Assert(parent.IsTypeDef);
startRid = GetEventRange(parent.Rid, out count);
}
return UseEventPtrTable ? EnumerationIndirection.Event : EnumerationIndirection.None;
case MetadataTokenType.FieldDef:
if (parent.IsNull) {
count = FieldTable.NumberOfRows;
startRid = 1;
} else {
Debug.Assert(parent.IsTypeDef);
startRid = GetFieldRange(parent.Rid, out count);
}
return UseFieldPtrTable ? EnumerationIndirection.Field : EnumerationIndirection.None;
case MetadataTokenType.ParamDef:
if (parent.IsNull) {
count = ParamTable.NumberOfRows;
startRid = 1;
} else {
Debug.Assert(parent.IsMethodDef);
startRid = GetParamRange(parent.Rid, out count);
}
return UseParamPtrTable ? EnumerationIndirection.Param : EnumerationIndirection.None;
case MetadataTokenType.CustomAttribute:
if (parent.IsNull) {
count = CustomAttributeTable.NumberOfRows;
startRid = 1;
} else {
startRid = CustomAttributeTable.FindCustomAttributesForToken(parent, out count);
}
return EnumerationIndirection.None;
case MetadataTokenType.InterfaceImpl:
if (parent.IsNull) {
count = InterfaceImplTable.NumberOfRows;
startRid = 1;
} else {
Debug.Assert(parent.IsTypeDef);
startRid = InterfaceImplTable.FindInterfaceImplForType(parent.Rid, out count);
}
return EnumerationIndirection.None;
case MetadataTokenType.GenericPar:
if (parent.IsNull) {
count = GenericParamTable.NumberOfRows;
startRid = 1;
} else if (parent.IsTypeDef) {
startRid = GenericParamTable.FindGenericParametersForType(parent.Rid, out count);
} else {
Debug.Assert(parent.IsMethodDef);
startRid = GenericParamTable.FindGenericParametersForMethod(parent.Rid, out count);
}
return EnumerationIndirection.None;
case MetadataTokenType.GenericParamConstraint:
if (parent.IsNull) {
count = GenericParamConstraintTable.NumberOfRows;
startRid = 1;
} else {
Debug.Assert(parent.IsGenericParam);
startRid = GenericParamConstraintTable.FindConstraintForGenericParam(parent.Rid, out count);
}
return EnumerationIndirection.None;
case MetadataTokenType.AssemblyRef:
case MetadataTokenType.ModuleRef:
case MetadataTokenType.File:
case MetadataTokenType.TypeDef:
case MetadataTokenType.TypeSpec:
case MetadataTokenType.TypeRef:
case MetadataTokenType.NestedClass:
case MetadataTokenType.ExportedType:
case MetadataTokenType.MethodSpec:
case MetadataTokenType.MemberRef:
case MetadataTokenType.Signature:
case MetadataTokenType.ManifestResource:
Debug.Assert(parent.IsNull);
count = _tableRowCounts[(int)type >> 24];
startRid = 1;
return EnumerationIndirection.None;
default:
Debug.Assert(false);
throw new InvalidOperationException();
}
}
public override MethodBase?ResolveMethod(
int metadataToken,
Type[]?genericTypeArguments,
Type[]?genericMethodArguments
)
{
try
{
MetadataToken tk = new MetadataToken(metadataToken);
if (!tk.IsMethodDef && !tk.IsMethodSpec)
{
if (!tk.IsMemberRef)
{
throw new ArgumentException(
SR.Format(SR.Argument_ResolveMethod, tk, this),
nameof(metadataToken)
);
}
unsafe
{
ConstArray sig = MetadataImport.GetMemberRefProps(tk);
if (*(MdSigCallingConvention *)sig.Signature == MdSigCallingConvention.Field)
{
throw new ArgumentException(
SR.Format(SR.Argument_ResolveMethod, tk, this),
nameof(metadataToken)
);
}
}
}
RuntimeTypeHandle[]? typeArgs = null;
RuntimeTypeHandle[]? methodArgs = null;
if (genericTypeArguments?.Length > 0)
{
typeArgs = ConvertToTypeHandleArray(genericTypeArguments);
}
if (genericMethodArguments?.Length > 0)
{
methodArgs = ConvertToTypeHandleArray(genericMethodArguments);
}
ModuleHandle moduleHandle = new ModuleHandle(this);
IRuntimeMethodInfo methodHandle = moduleHandle
.ResolveMethodHandle(tk, typeArgs, methodArgs)
.GetMethodInfo();
Type declaringType = RuntimeMethodHandle.GetDeclaringType(methodHandle);
if (declaringType.IsGenericType || declaringType.IsArray)
{
MetadataToken tkDeclaringType = new MetadataToken(
MetadataImport.GetParentToken(tk)
);
if (tk.IsMethodSpec)
{
tkDeclaringType = new MetadataToken(
MetadataImport.GetParentToken(tkDeclaringType)
);
}
declaringType = ResolveType(
tkDeclaringType,
genericTypeArguments,
genericMethodArguments
);
}
return(RuntimeType.GetMethodBase(declaringType as RuntimeType, methodHandle));
}
catch (BadImageFormatException e)
{
throw new ArgumentException(SR.Argument_BadImageFormatExceptionResolve, e);
}
}