public static bool CompareTypeReferenceToDefinition(TypeReferenceHandle tr1, MetadataReader mr1, TypeDefinitionHandle td2, MetadataReader mr2) { // TODO! The correct implementation here is probably to call into the assembly binder, but that's not available due to layering. // For now, just implement comparison, which will be equivalent in all cases until we support loading multiple copies of the same assembly TypeReference trData1 = mr1.GetTypeReference(tr1); TypeDefinition tdData2 = mr2.GetTypeDefinition(td2); if (!trData1.TypeName.StringEquals(tdData2.Name.GetConstantStringValue(mr2).Value, mr1)) return false; switch (trData1.ParentNamespaceOrType.HandleType) { case HandleType.TypeReference: if (tdData2.EnclosingType.IsNull(mr2)) return false; return CompareTypeReferenceToDefinition(trData1.ParentNamespaceOrType.ToTypeReferenceHandle(mr1), mr1, tdData2.EnclosingType, mr2); case HandleType.NamespaceReference: return CompareNamespaceReferenceToDefinition(trData1.ParentNamespaceOrType.ToNamespaceReferenceHandle(mr1), mr1, tdData2.NamespaceDefinition, mr2); default: Debug.Assert(false); throw new BadImageFormatException(); } }
private TypeDefTreatment GetWellKnownTypeDefinitionTreatment(TypeDefinitionHandle typeDef) { InitializeProjectedTypes(); StringHandle name = TypeDefTable.GetName(typeDef); int index = StringStream.BinarySearchRaw(s_projectedTypeNames, name); if (index < 0) { return TypeDefTreatment.None; } StringHandle namespaceName = TypeDefTable.GetNamespace(typeDef); if (StringStream.EqualsRaw(namespaceName, StringStream.GetVirtualValue(s_projectionInfos[index].ClrNamespace))) { return s_projectionInfos[index].Treatment; } // TODO: we can avoid this comparison if info.DotNetNamespace == info.WinRtNamespace if (StringStream.EqualsRaw(namespaceName, s_projectionInfos[index].WinRTNamespace)) { return s_projectionInfos[index].Treatment | TypeDefTreatment.MarkInternalFlag; } return TypeDefTreatment.None; }
internal static ClassLayoutRow GetTypeLayout(this MetadataReader reader, TypeDefinitionHandle typeDef) { uint rowId = reader.ClassLayoutTable.FindRow(typeDef); if (rowId == 0) { return default(ClassLayoutRow); } return GetTypeLayout(reader, rowId); }
internal EcmaType(EcmaModule module, TypeDefinitionHandle handle) { _module = module; _handle = handle; _typeDefinition = module.MetadataReader.GetTypeDefinition(handle); _baseType = this; // Not yet initialized flag #if DEBUG // Initialize name eagerly in debug builds for convenience this.ToString(); #endif }
protected RuntimeInspectionOnlyNamedType(MetadataReader reader, TypeDefinitionHandle typeDefinitionHandle) : base() { #if DEBUG if (!(this.InternalViolatesTypeIdentityRules)) { RuntimeTypeHandle runtimeTypeHandle; if (ReflectionCoreExecution.ExecutionEnvironment.TryGetNamedTypeForMetadata(reader, typeDefinitionHandle, out runtimeTypeHandle)) Debug.Assert(false, "Type identity violation: You must use a RuntimeEENamedType to represent this type as RH has generated an EEType for it."); } #endif _reader = reader; _typeDefinitionHandle = typeDefinitionHandle; _typeDefinition = _typeDefinitionHandle.GetTypeDefinition(_reader); }
/// <summary> /// Returns true if the nested type should be imported. /// </summary> public static bool ShouldImportNestedType(this PEModule module, TypeDefinitionHandle typeDef) { // Currently, it appears that we must import ALL types, even private ones, // in order to maintain language semantics. This is because a class may implement // private interfaces, and we use the interfaces (even if inaccessible) to determine // conversions. For example: // // public class A: IEnumerable<A.X> // { // private class X: ICloneable {} // } // // Code compiling against A can convert A to IEnumerable<ICloneable>. Knowing this requires // importing the type A.X. return true; }
internal uint CalculateTypeDefTreatmentAndRowId(TypeDefinitionHandle handle) { Debug.Assert(_metadataKind != MetadataKind.Ecma335); TypeDefTreatment treatment; TypeAttributes flags = TypeDefTable.GetFlags(handle); Handle extends = TypeDefTable.GetExtends(handle); if ((flags & TypeAttributes.WindowsRuntime) != 0) { if (_metadataKind == MetadataKind.WindowsMetadata) { treatment = GetWellKnownTypeDefinitionTreatment(handle); if (treatment != TypeDefTreatment.None) { return(TreatmentAndRowId((byte)treatment, handle.RowId)); } // Is this an attribute? if (extends.Kind == HandleKind.TypeReference && IsSystemAttribute((TypeReferenceHandle)extends)) { treatment = TypeDefTreatment.NormalAttribute; } else { treatment = TypeDefTreatment.NormalNonAttribute; } } else if (_metadataKind == MetadataKind.ManagedWindowsMetadata && NeedsWinRTPrefix(flags, extends)) { // WinMDExp emits two versions of RuntimeClasses and Enums: // // public class Foo {} // the WinRT reference class // internal class <CLR>Foo {} // the implementation class that we want WinRT consumers to ignore // // The adapter's job is to undo WinMDExp's transformations. I.e. turn the above into: // // internal class <WinRT>Foo {} // the WinRT reference class that we want CLR consumers to ignore // public class Foo {} // the implementation class // // We only add the <WinRT> prefix here since the WinRT view is the only view that is marked WindowsRuntime // De-mangling the CLR name is done below. // tomat: The CLR adapter implements a back-compat quirk: Enums exported with an older WinMDExp have only one version // not marked with tdSpecialName. These enums should *not* be mangled and flipped to private. // We don't implement this flag since the WinMDs producted by the older WinMDExp are not used in the wild. 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 & TypeAttributes.Interface) == 0 && HasAttribute(handle, "Windows.UI.Xaml", "TreatAsAbstractComposableClassAttribute")) { treatment |= TypeDefTreatment.MarkAbstractFlag; } } } else if (_metadataKind == MetadataKind.ManagedWindowsMetadata && IsClrImplementationType(handle)) { // <CLR> implementation classes are not marked WindowsRuntime, but still need to be modified // by the adapter. treatment = TypeDefTreatment.UnmangleWinRTName; } else { treatment = TypeDefTreatment.None; } return(TreatmentAndRowId((byte)treatment, handle.RowId)); }
internal void GetMethodRange(TypeDefinitionHandle typeDef, out int firstMethodRowId, out int lastMethodRowId) { uint typeDefRowId = typeDef.RowId; firstMethodRowId = (int)this.TypeDefTable.GetMethodStart(typeDefRowId); if (firstMethodRowId == 0) { firstMethodRowId = 1; lastMethodRowId = 0; } else if (typeDefRowId == this.TypeDefTable.NumberOfRows) { lastMethodRowId = (int)(this.UseMethodPtrTable ? this.MethodPtrTable.NumberOfRows : this.MethodDefTable.NumberOfRows); } else { lastMethodRowId = (int)this.TypeDefTable.GetMethodStart(typeDefRowId + 1) - 1; } }
private bool IsClrImplementationType(TypeDefinitionHandle typeDef) { var attrs = TypeDefTable.GetFlags(typeDef); if ((attrs & (TypeAttributes.VisibilityMask | TypeAttributes.SpecialName)) != TypeAttributes.SpecialName) { return false; } return StringStream.StartsWithRaw(TypeDefTable.GetName(typeDef), ClrPrefix); }
public void AddPropertyMap(TypeDefinitionHandle declaringType, PropertyDefinitionHandle propertyList) { _propertyMapTable.Add(new PropertyMapRow { Parent = (uint)MetadataTokens.GetRowNumber(declaringType), PropertyList = (uint)MetadataTokens.GetRowNumber(propertyList) }); }
private static PENamedTypeSymbol GetType(PEModuleSymbol module, TypeDefinitionHandle typeHandle) { var metadataDecoder = new MetadataDecoder(module); return (PENamedTypeSymbol)metadataDecoder.GetTypeOfToken(typeHandle); }
internal void GetInterfaceImplRange( TypeDefinitionHandle typeDef, out int firstImplRowId, out int lastImplRowId) { int typeDefRid = typeDef.RowId; int startRowNumber, endRowNumber; this.Block.BinarySearchReferenceRange( this.NumberOfRows, this.RowSize, _ClassOffset, (uint)typeDefRid, _IsTypeDefTableRowRefSizeSmall, out startRowNumber, out endRowNumber); if (startRowNumber == -1) { firstImplRowId = 1; lastImplRowId = 0; } else { firstImplRowId = startRowNumber + 1; lastImplRowId = endRowNumber + 1; } }
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)); } }
public sealed override IEnumerable <CustomAttributeData> GetPsuedoCustomAttributes(MetadataReader reader, TypeDefinitionHandle typeDefinitionHandle) { TypeAttributes attributes = typeDefinitionHandle.GetTypeDefinition(reader).Flags; if (0 != (attributes & TypeAttributes.Import)) { yield return(ReflectionCoreExecution.ExecutionDomain.GetCustomAttributeData(typeof(ComImportAttribute), null, null)); } }
public GenericContext(TypeDefinitionHandle declaringType, PEFile module) { this.module = module; this.declaringType = declaringType; }
public GenericContext(MethodDefinitionHandle method, PEFile module) { this.module = module; this.method = method; this.declaringType = module.Metadata.GetMethodDefinition(method).GetDeclaringType(); }
ITypeSignature ISimpleTypeProvider <ITypeSignature> .GetTypeFromDefinition(MetadataReader reader, TypeDefinitionHandle handle, byte rawTypeKind) { return(new TypeDefinition(handle)); }
public TypeDefinition(TypeDefinitionHandle handle) { this.handle = handle; }
internal TypeDefinitionHandle FindEnclosingType(TypeDefinitionHandle nestedTypeDef) { int rowNumber = this.Block.BinarySearchReference( this.NumberOfRows, this.RowSize, _NestedClassOffset, (uint)nestedTypeDef.RowId, _IsTypeDefTableRowRefSizeSmall); if (rowNumber == -1) { return default(TypeDefinitionHandle); } return TypeDefinitionHandle.FromRowId(this.Block.PeekReference(rowNumber * this.RowSize + _EnclosingClassOffset, _IsTypeDefTableRowRefSizeSmall)); }
public sealed override IEnumerable <CustomAttributeData> GetPsuedoCustomAttributes(MetadataReader reader, FieldHandle fieldHandle, TypeDefinitionHandle declaringTypeHandle) { TypeAttributes layoutKind = declaringTypeHandle.GetTypeDefinition(reader).Flags & TypeAttributes.LayoutMask; if (layoutKind == TypeAttributes.ExplicitLayout) { int offset = (int)(fieldHandle.GetField(reader).Offset); CustomAttributeTypedArgument offsetArgument = ExtensibleCustomAttributeData.CreateCustomAttributeTypedArgument(typeof(Int32), offset); yield return(ReflectionCoreExecution.ExecutionDomain.GetCustomAttributeData(typeof(FieldOffsetAttribute), new CustomAttributeTypedArgument[] { offsetArgument }, null)); } }
internal void GetFieldRange(TypeDefinitionHandle typeDef, out int firstFieldRowId, out int lastFieldRowId) { int typeDefRowId = typeDef.RowId; firstFieldRowId = this.TypeDefTable.GetFieldStart(typeDefRowId); if (firstFieldRowId == 0) { firstFieldRowId = 1; lastFieldRowId = 0; } else if (typeDefRowId == this.TypeDefTable.NumberOfRows) { lastFieldRowId = (this.UseFieldPtrTable) ? this.FieldPtrTable.NumberOfRows : this.FieldTable.NumberOfRows; } else { lastFieldRowId = this.TypeDefTable.GetFieldStart(typeDefRowId + 1) - 1; } }
public sealed override IEnumerable <CustomAttributeData> GetPsuedoCustomAttributes(MetadataReader reader, EventHandle eventHandle, TypeDefinitionHandle declaringTypeHandle) { return(Empty <CustomAttributeData> .Enumerable); }
public void AddInterfaceImplementation( TypeDefinitionHandle type, EntityHandle implementedInterface) { _interfaceImplTable.Add(new InterfaceImplRow { Class = (uint)MetadataTokens.GetRowNumber(type), Interface = (uint)CodedIndex.ToTypeDefOrRef(implementedInterface) }); }
protected override IEntityHandleObject CreateValueFromKey(EntityHandle handle) { object item; switch (handle.Kind) { case HandleKind.TypeDefinition: item = new EcmaType(_module, (TypeDefinitionHandle)handle); break; case HandleKind.MethodDefinition: { MethodDefinitionHandle methodDefinitionHandle = (MethodDefinitionHandle)handle; TypeDefinitionHandle typeDefinitionHandle = _module._metadataReader.GetMethodDefinition(methodDefinitionHandle).GetDeclaringType(); EcmaType type = (EcmaType)_module.GetObject(typeDefinitionHandle); item = new EcmaMethod(type, methodDefinitionHandle); } break; case HandleKind.FieldDefinition: { FieldDefinitionHandle fieldDefinitionHandle = (FieldDefinitionHandle)handle; TypeDefinitionHandle typeDefinitionHandle = _module._metadataReader.GetFieldDefinition(fieldDefinitionHandle).GetDeclaringType(); EcmaType type = (EcmaType)_module.GetObject(typeDefinitionHandle); item = new EcmaField(type, fieldDefinitionHandle); } break; case HandleKind.TypeReference: item = _module.ResolveTypeReference((TypeReferenceHandle)handle); break; case HandleKind.MemberReference: item = _module.ResolveMemberReference((MemberReferenceHandle)handle); break; case HandleKind.AssemblyReference: item = _module.ResolveAssemblyReference((AssemblyReferenceHandle)handle); break; case HandleKind.TypeSpecification: item = _module.ResolveTypeSpecification((TypeSpecificationHandle)handle); break; case HandleKind.MethodSpecification: item = _module.ResolveMethodSpecification((MethodSpecificationHandle)handle); break; case HandleKind.ExportedType: item = _module.ResolveExportedType((ExportedTypeHandle)handle); break; case HandleKind.StandaloneSignature: item = _module.ResolveStandaloneSignature((StandaloneSignatureHandle)handle); break; case HandleKind.ModuleDefinition: // ECMA-335 Partition 2 II.22.38 1d: This should not occur in a CLI ("compressed metadata") module, // but resolves to "current module". item = _module; break; case HandleKind.ModuleReference: item = _module.ResolveModuleReference((ModuleReferenceHandle)handle); break; default: throw new BadImageFormatException("Unknown metadata token type: " + handle.Kind); } switch (handle.Kind) { case HandleKind.TypeDefinition: case HandleKind.MethodDefinition: case HandleKind.FieldDefinition: // type/method/field definitions directly correspond to their target item. return((IEntityHandleObject)item); default: // Everything else is some form of reference which cannot be self-describing return(new EcmaObjectLookupWrapper(handle, item)); } }
public void AddMethodImplementation( TypeDefinitionHandle type, EntityHandle methodBody, EntityHandle methodDeclaration) { _methodImplTable.Add(new MethodImplRow { Class = (uint)MetadataTokens.GetRowNumber(type), MethodBody = (uint)CodedIndex.ToMethodDefOrRef(methodBody), MethodDecl = (uint)CodedIndex.ToMethodDefOrRef(methodDeclaration) }); }
//============================================================================================== // Reflection Mapping Tables //============================================================================================== public abstract bool TryGetMetadataForNamedType(RuntimeTypeHandle runtimeTypeHandle, out MetadataReader metadataReader, out TypeDefinitionHandle typeDefHandle);
public Type GetTypeFromDefinition(MetadataReader reader, TypeDefinitionHandle handle, byte rawTypeKind) => (Type)cx.Create(handle);
public abstract bool TryGetNamedTypeForMetadata(MetadataReader metadataReader, TypeDefinitionHandle typeDefHandle, out RuntimeTypeHandle runtimeTypeHandle);
internal void GetPropertyRange(TypeDefinitionHandle typeDef, out int firstPropertyRowId, out int lastPropertyRowId) { uint propertyMapRowId = this.PropertyMapTable.FindPropertyMapRowIdFor(typeDef); if (propertyMapRowId == 0) { firstPropertyRowId = 1; lastPropertyRowId = 0; return; } firstPropertyRowId = (int)this.PropertyMapTable.GetPropertyListStartFor(propertyMapRowId); if (propertyMapRowId == this.PropertyMapTable.NumberOfRows) { lastPropertyRowId = (int)(this.UsePropertyPtrTable ? this.PropertyPtrTable.NumberOfRows : this.PropertyTable.NumberOfRows); } else { lastPropertyRowId = (int)this.PropertyMapTable.GetPropertyListStartFor(propertyMapRowId + 1) - 1; } }
public abstract IEnumerable <CustomAttributeData> GetPsuedoCustomAttributes(MetadataReader reader, TypeDefinitionHandle typeDefinitionHandle);
private uint CalculateMethodDefTreatmentAndRowId(MethodDefinitionHandle methodDef) { MethodDefTreatment treatment = MethodDefTreatment.Implementation; TypeDefinitionHandle parentTypeDef = GetDeclaringType(methodDef); TypeAttributes parentFlags = TypeDefTable.GetFlags(parentTypeDef); if ((parentFlags & TypeAttributes.WindowsRuntime) != 0) { if (IsClrImplementationType(parentTypeDef)) { treatment = MethodDefTreatment.Implementation; } else if (parentFlags.IsNested()) { treatment = MethodDefTreatment.Implementation; } else if ((parentFlags & TypeAttributes.Interface) != 0) { treatment = MethodDefTreatment.InterfaceMethod; } else if (_metadataKind == MetadataKind.ManagedWindowsMetadata && (parentFlags & TypeAttributes.Public) == 0) { treatment = MethodDefTreatment.Implementation; } else { treatment = MethodDefTreatment.Other; var parentBaseType = TypeDefTable.GetExtends(parentTypeDef); if (parentBaseType.Kind == HandleKind.TypeReference) { switch (GetSpecialTypeRefTreatment((TypeReferenceHandle)parentBaseType)) { case TypeRefTreatment.SystemAttribute: treatment = MethodDefTreatment.AttributeMethod; break; case TypeRefTreatment.SystemDelegate: treatment = MethodDefTreatment.DelegateMethod | MethodDefTreatment.MarkPublicFlag; break; } } } } if (treatment == MethodDefTreatment.Other) { // we want to hide the method if it implements // only redirected interfaces // We also want to check if the methodImpl is IClosable.Close, // so we can change the name bool seenRedirectedInterfaces = false; bool seenNonRedirectedInterfaces = false; bool isIClosableClose = false; foreach (var methodImplHandle in new MethodImplementationHandleCollection(this, parentTypeDef)) { MethodImplementation methodImpl = GetMethodImplementation(methodImplHandle); if (methodImpl.MethodBody == methodDef) { Handle declaration = methodImpl.MethodDeclaration; // See if this MethodImpl implements a redirected interface // In WinMD, MethodImpl will always use MemberRef and TypeRefs to refer to redirected interfaces, // even if they are in the same module. if (declaration.Kind == HandleKind.MemberReference && ImplementsRedirectedInterface((MemberReferenceHandle)declaration, out isIClosableClose)) { seenRedirectedInterfaces = true; if (isIClosableClose) { // This method implements IClosable.Close // Let's rename to IDisposable later // Once we know this implements IClosable.Close, we are done // looking break; } } else { // Now we know this implements a non-redirected interface // But we need to keep looking, just in case we got a methodimpl that // implements the IClosable.Close method and needs to be renamed seenNonRedirectedInterfaces = true; } } } if (isIClosableClose) { treatment = MethodDefTreatment.DisposeMethod; } else if (seenRedirectedInterfaces && !seenNonRedirectedInterfaces) { // Only hide if all the interfaces implemented are redirected treatment = MethodDefTreatment.HiddenInterfaceImplementation; } } // If treatment is other, then this is a non-managed WinRT runtime class definition // Find out about various bits that we apply via attributes and name parsing if (treatment == MethodDefTreatment.Other) { treatment |= GetMethodTreatmentFromCustomAttributes(methodDef); } return(TreatmentAndRowId((byte)treatment, methodDef.RowId)); }
public abstract IEnumerable <CustomAttributeData> GetPsuedoCustomAttributes(MetadataReader reader, EventHandle eventHandle, TypeDefinitionHandle declaringTypeHandle);
public void SimpleSignatureProviderCoverage() { using (FileStream stream = File.OpenRead(AssemblyPathHelper.GetAssemblyLocation(typeof(SignaturesToDecode <>).GetTypeInfo().Assembly))) using (var peReader = new PEReader(stream)) { MetadataReader reader = peReader.GetMetadataReader(); var provider = new DisassemblingTypeProvider(); TypeDefinitionHandle typeHandle = TestMetadataResolver.FindTestType(reader, typeof(SignaturesToDecode <>)); Assert.Equal("System.Reflection.Metadata.Decoding.Tests.SignatureDecoderTests/SignaturesToDecode`1", provider.GetTypeFromHandle(reader, genericContext: null, handle: typeHandle)); TypeDefinition type = reader.GetTypeDefinition(typeHandle); Dictionary <string, string> expectedFields = GetExpectedFieldSignatures(); ImmutableArray <string> genericTypeParameters = type.GetGenericParameters().Select(h => reader.GetString(reader.GetGenericParameter(h).Name)).ToImmutableArray(); var genericTypeContext = new DisassemblingGenericContext(genericTypeParameters, ImmutableArray <string> .Empty); foreach (var fieldHandle in type.GetFields()) { FieldDefinition field = reader.GetFieldDefinition(fieldHandle); string fieldName = reader.GetString(field.Name); string expected; Assert.True(expectedFields.TryGetValue(fieldName, out expected), "Unexpected field: " + fieldName); Assert.Equal(expected, field.DecodeSignature(provider, genericTypeContext)); } Dictionary <string, string> expectedMethods = GetExpectedMethodSignatures(); foreach (var methodHandle in type.GetMethods()) { MethodDefinition method = reader.GetMethodDefinition(methodHandle); ImmutableArray <string> genericMethodParameters = method.GetGenericParameters().Select(h => reader.GetString(reader.GetGenericParameter(h).Name)).ToImmutableArray(); var genericMethodContext = new DisassemblingGenericContext(genericTypeParameters, genericMethodParameters); string methodName = reader.GetString(method.Name); string expected; Assert.True(expectedMethods.TryGetValue(methodName, out expected), "Unexpected method: " + methodName); MethodSignature <string> signature = method.DecodeSignature(provider, genericMethodContext); Assert.True(signature.Header.Kind == SignatureKind.Method); if (methodName.StartsWith("Generic")) { Assert.Equal(1, signature.GenericParameterCount); } else { Assert.Equal(0, signature.GenericParameterCount); } Assert.True(signature.GenericParameterCount <= 1 && (methodName != "GenericMethodParameter" || signature.GenericParameterCount == 1)); Assert.Equal(expected, provider.GetFunctionPointerType(signature)); } Dictionary <string, string> expectedProperties = GetExpectedPropertySignatures(); foreach (var propertyHandle in type.GetProperties()) { PropertyDefinition property = reader.GetPropertyDefinition(propertyHandle); string propertyName = reader.GetString(property.Name); string expected; Assert.True(expectedProperties.TryGetValue(propertyName, out expected), "Unexpected property: " + propertyName); MethodSignature <string> signature = property.DecodeSignature(provider, genericTypeContext); Assert.True(signature.Header.Kind == SignatureKind.Property); Assert.Equal(expected, provider.GetFunctionPointerType(signature)); } Dictionary <string, string> expectedEvents = GetExpectedEventSignatures(); foreach (var eventHandle in type.GetEvents()) { EventDefinition @event = reader.GetEventDefinition(eventHandle); string eventName = reader.GetString(@event.Name); string expected; Assert.True(expectedEvents.TryGetValue(eventName, out expected), "Unexpected event: " + eventName); Assert.Equal(expected, provider.GetTypeFromHandle(reader, genericTypeContext, @event.Type)); } Assert.Equal($"[{MetadataReaderTestHelpers.CollectionsAssemblyName}]System.Collections.Generic.List`1<!T>", provider.GetTypeFromHandle(reader, genericTypeContext, handle: type.BaseType)); } }
/// <inheritdoc cref="ISimpleTypeProvider{TType}" /> public TypeDescriptor GetTypeFromDefinition(MetadataReader reader, TypeDefinitionHandle handle, byte rawTypeKind) { var definition = reader.GetTypeDefinition(handle); return(reader.ToTypeDescriptor(definition)); }
internal EntityHandle GetExtends(TypeDefinitionHandle handle) { int rowOffset = (handle.RowId - 1) * this.RowSize; return TypeDefOrRefTag.ConvertToHandle(this.Block.PeekTaggedReference(rowOffset + _ExtendsOffset, _IsTypeDefOrRefRefSizeSmall)); }
public IHandleTypeNamedWrapper GetTypeFromDefinition(MetadataReader reader, TypeDefinitionHandle handle, byte rawTypeKind) { var assemblyMetadata = MetadataRepository.GetAssemblyMetadataForReader(reader); return(TypeWrapper.Create(handle, assemblyMetadata)); }
internal GenericParameterHandleCollection FindGenericParametersForType(TypeDefinitionHandle typeDef) { ushort count = 0; uint searchCodedTag = TypeOrMethodDefTag.ConvertTypeDefRowIdToTag(typeDef); int startRid = (int)this.BinarySearchTag(searchCodedTag, ref count); return new GenericParameterHandleCollection(startRid, count); }
public TypeDesc GetTypeFromDefinition(MetadataReader reader, TypeDefinitionHandle handle, SignatureTypeHandleCode code) { Debug.Assert(reader == _module.MetadataReader); return(_module.GetType(handle)); }
// // Main routine to resolve a typeDefinition. // internal static RuntimeType ResolveTypeDefinition(this ReflectionDomain reflectionDomain, MetadataReader reader, TypeDefinitionHandle typeDefinitionHandle) { return RuntimeTypeUnifierEx.GetNamedType(reader, typeDefinitionHandle); }
public static DiscoveredType FromDefinedType(MetadataReader reader, TypeDefinitionHandle handle) => new DiscoveredType(reader, handle);
private static String GetTypeFullNameFromTypeDef(TypeDefinitionHandle typeDefinitionHandle, MetadataReader reader, List<int> genericParameterOffsets) { String s = ""; TypeDefinition typeDefinition = typeDefinitionHandle.GetTypeDefinition(reader); s = typeDefinition.Name.GetString(reader); TypeDefinitionHandle enclosingTypeDefHandle = typeDefinition.EnclosingType; if (!enclosingTypeDefHandle.IsNull(reader)) { String containingTypeName = GetTypeFullNameFromTypeDef(enclosingTypeDefHandle, reader, genericParameterOffsets); s = containingTypeName + "." + s; } else { NamespaceDefinitionHandle namespaceHandle = typeDefinition.NamespaceDefinition; for (; ;) { NamespaceDefinition namespaceDefinition = namespaceHandle.GetNamespaceDefinition(reader); String namespacePart = namespaceDefinition.Name.GetStringOrNull(reader); if (namespacePart == null) break; // Reached the root namespace. s = namespacePart + "." + s; if (namespaceDefinition.ParentScopeOrNamespace.HandleType != HandleType.NamespaceDefinition) break; // Should have reached the root namespace first but this helper is for ToString() - better to // return partial information than crash. namespaceHandle = namespaceDefinition.ParentScopeOrNamespace.ToNamespaceDefinitionHandle(reader); } } return ConvertBackTickNameToNameWithReducerInputFormat(s, genericParameterOffsets); }
public object GetTypeFromDefinition(MetadataReader reader, TypeDefinitionHandle handle, byte rawTypeKind) => null;
public void AddTypeLayout( TypeDefinitionHandle type, ushort packingSize, uint size) { _classLayoutTable.Add(new ClassLayoutRow { Parent = (uint)MetadataTokens.GetRowNumber(type), PackingSize = packingSize, ClassSize = size }); }
public void TestCustomAttributeDecoder() { using (FileStream stream = File.OpenRead(typeof(HasAttributes).GetTypeInfo().Assembly.Location)) using (var peReader = new PEReader(stream)) { MetadataReader reader = peReader.GetMetadataReader(); var provider = new CustomAttributeTypeProvider(); TypeDefinitionHandle typeDefHandle = TestMetadataResolver.FindTestType(reader, typeof(HasAttributes)); int i = 0; foreach (CustomAttributeHandle attributeHandle in reader.GetCustomAttributes(typeDefHandle)) { CustomAttribute attribute = reader.GetCustomAttribute(attributeHandle); CustomAttributeValue <string> value = attribute.DecodeValue(provider); switch (i++) { case 0: Assert.Empty(value.FixedArguments); Assert.Empty(value.NamedArguments); break; case 1: Assert.Equal(3, value.FixedArguments.Length); Assert.Equal("string", value.FixedArguments[0].Type); Assert.Equal("0", value.FixedArguments[0].Value); Assert.Equal("int32", value.FixedArguments[1].Type); Assert.Equal(1, value.FixedArguments[1].Value); Assert.Equal("float64", value.FixedArguments[2].Type); Assert.Equal(2.0, value.FixedArguments[2].Value); Assert.Empty(value.NamedArguments); break; case 2: Assert.Equal(3, value.NamedArguments.Length); Assert.Equal(CustomAttributeNamedArgumentKind.Field, value.NamedArguments[0].Kind); Assert.Equal("StringField", value.NamedArguments[0].Name); Assert.Equal("string", value.NamedArguments[0].Type); Assert.Equal("0", value.NamedArguments[0].Value); Assert.Equal(CustomAttributeNamedArgumentKind.Field, value.NamedArguments[1].Kind); Assert.Equal("Int32Field", value.NamedArguments[1].Name); Assert.Equal("int32", value.NamedArguments[1].Type); Assert.Equal(1, value.NamedArguments[1].Value); Assert.Equal(CustomAttributeNamedArgumentKind.Property, value.NamedArguments[2].Kind); Assert.Equal("SByteEnumArrayProperty", value.NamedArguments[2].Name); Assert.Equal(typeof(SByteEnum).FullName + "[]", value.NamedArguments[2].Type); var array = (ImmutableArray <CustomAttributeTypedArgument <string> >)(value.NamedArguments[2].Value); Assert.Equal(1, array.Length); Assert.Equal(typeof(SByteEnum).FullName, array[0].Type); Assert.Equal((sbyte)SByteEnum.Value, array[0].Value); break; default: // TODO: https://github.com/dotnet/runtime/issues/16552 // The other cases are missing corresponding assertions. This needs some refactoring to // be data-driven. A better approach would probably be to generically compare reflection // CustomAttributeData to S.R.M CustomAttributeValue for every test attribute applied. break; } } } }
public void AddNestedType( TypeDefinitionHandle type, TypeDefinitionHandle enclosingType) { _nestedClassTable.Add(new NestedClassRow { NestedClass = (uint)MetadataTokens.GetRowNumber(type), EnclosingClass = (uint)MetadataTokens.GetRowNumber(enclosingType) }); }
// // Q: Why is the type handle part of the unification key when it doesn't participate in the Equals/HashCode computations? // A: It's a passenger. // // The typeHandle argument is "redundant" in that it can be computed from the rest of the key. However, we have callers (Type.GetTypeFromHandle()) that // already have the typeHandle so to avoid an unnecessary round-trip computation, we require the caller to pass it in separately. // We allow it to ride along in the key object because the ConcurrentUnifier classes we use don't support passing "extra" parameters to // their Factory methods. // public UnificationKey(MetadataReader reader, TypeDefinitionHandle typeDefinitionHandle, RuntimeTypeHandle typeHandle) { Reader = reader; TypeDefinitionHandle = typeDefinitionHandle; TypeHandle = typeHandle; }
public void AddEventMap(TypeDefinitionHandle declaringType, EventDefinitionHandle eventList) { _eventMapTable.Add(new EventMapRow { Parent = (uint)MetadataTokens.GetRowNumber(declaringType), EventList = (uint)MetadataTokens.GetRowNumber(eventList) }); }
/// <summary> /// NestedClass Table Columns: /// NestedClass (RID to TypeDef) nestee /// EnclosingClass (RID to TypeDef) /// </summary> private void ValidateNestedClass(MetadataReader reader, TypeDefinitionHandle typeDef, bool isMod = false) { // var expNC = new uint[] { 4, 5, 6 }; var expClasses = new int[][] { new int[] { 4, 5, 6 }, new int[] { 3, 3, 5 } }; var modClasses = new int[][] { new int[] { 4, 5, 6, 7 }, new int[] { 2, 3, 3, 5 } }; int rid = reader.NestedClassTable.FindEnclosingType(typeDef).RowId; int[][] classes = expClasses; if (isMod) { classes = modClasses; } Assert.Equal(rid, classes[1].Where((x, index) => classes[0][index] == typeDef.RowId).First()); }
internal uint CalculateTypeDefTreatmentAndRowId(TypeDefinitionHandle handle) { Debug.Assert(_metadataKind != MetadataKind.Ecma335); TypeDefTreatment treatment; TypeAttributes flags = TypeDefTable.GetFlags(handle); EntityHandle extends = TypeDefTable.GetExtends(handle); if ((flags & TypeAttributes.WindowsRuntime) != 0) { if (_metadataKind == MetadataKind.WindowsMetadata) { treatment = GetWellKnownTypeDefinitionTreatment(handle); if (treatment != TypeDefTreatment.None) { return TreatmentAndRowId((byte)treatment, handle.RowId); } // Is this an attribute? if (extends.Kind == HandleKind.TypeReference && IsSystemAttribute((TypeReferenceHandle)extends)) { treatment = TypeDefTreatment.NormalAttribute; } else { treatment = TypeDefTreatment.NormalNonAttribute; } } else if (_metadataKind == MetadataKind.ManagedWindowsMetadata && NeedsWinRTPrefix(flags, extends)) { // WinMDExp emits two versions of RuntimeClasses and Enums: // // public class Foo {} // the WinRT reference class // internal class <CLR>Foo {} // the implementation class that we want WinRT consumers to ignore // // The adapter's job is to undo WinMDExp's transformations. I.e. turn the above into: // // internal class <WinRT>Foo {} // the WinRT reference class that we want CLR consumers to ignore // public class Foo {} // the implementation class // // We only add the <WinRT> prefix here since the WinRT view is the only view that is marked WindowsRuntime // De-mangling the CLR name is done below. // tomat: The CLR adapter implements a back-compat quirk: Enums exported with an older WinMDExp have only one version // not marked with tdSpecialName. These enums should *not* be mangled and flipped to private. // We don't implement this flag since the WinMDs producted by the older WinMDExp are not used in the wild. 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 & TypeAttributes.Interface) == 0 && HasAttribute(handle, "Windows.UI.Xaml", "TreatAsAbstractComposableClassAttribute")) { treatment |= TypeDefTreatment.MarkAbstractFlag; } } } else if (_metadataKind == MetadataKind.ManagedWindowsMetadata && IsClrImplementationType(handle)) { // <CLR> implementation classes are not marked WindowsRuntime, but still need to be modified // by the adapter. treatment = TypeDefTreatment.UnmangleWinRTName; } else { treatment = TypeDefTreatment.None; } return TreatmentAndRowId((byte)treatment, handle.RowId); }
public TypeDefinition GetTypeDefinition(TypeDefinitionHandle handle) { // PERF: This code pattern is JIT friendly and results in very efficient code. return new TypeDefinition(this, GetTypeDefTreatmentAndRowId(handle)); }
public override int GetHashCode() { return(TypeDefinitionHandle.GetHashCode()); }
private MrType(TypeDefinitionHandle typeDefinitionHandle, MrAssembly assembly) { TypeDefinitionHandle = typeDefinitionHandle; Assembly = assembly; TypeDefinition = Assembly.Reader.GetTypeDefinition(typeDefinitionHandle); }
internal abstract bool TryGetTypeHandle(Cci.ITypeDefinition def, out TypeDefinitionHandle handle);
internal void GetEventRange(TypeDefinitionHandle typeDef, out int firstEventRowId, out int lastEventRowId) { uint eventMapRowId = this.EventMapTable.FindEventMapRowIdFor(typeDef); if (eventMapRowId == 0) { firstEventRowId = 1; lastEventRowId = 0; return; } firstEventRowId = (int)this.EventMapTable.GetEventListStartFor(eventMapRowId); if (eventMapRowId == this.EventMapTable.NumberOfRows) { lastEventRowId = (int)(this.UseEventPtrTable ? this.EventPtrTable.NumberOfRows : this.EventTable.NumberOfRows); } else { lastEventRowId = (int)this.EventMapTable.GetEventListStartFor(eventMapRowId + 1) - 1; } }
protected virtual bool IncludeTypeWhenDecompilingProject(Metadata.PEFile module, TypeDefinitionHandle type) { var metadata = module.Metadata; var typeDef = metadata.GetTypeDefinition(type); if (metadata.GetString(typeDef.Name) == "<Module>" || CSharpDecompiler.MemberIsHidden(module, type, settings)) { return(false); } if (metadata.GetString(typeDef.Namespace) == "XamlGeneratedNamespace" && metadata.GetString(typeDef.Name) == "GeneratedInternalTypeHelper") { return(false); } return(true); }
/// <summary> /// Returns an array of types nested in the specified type. /// </summary> internal ImmutableArray<TypeDefinitionHandle> GetNestedTypes(TypeDefinitionHandle typeDef) { if (this.lazyNestedTypesMap == null) { InitializeNestedTypesMap(); } ImmutableArray<TypeDefinitionHandle> nestedTypes; if (this.lazyNestedTypesMap.TryGetValue(typeDef, out nestedTypes)) { return nestedTypes; } return ImmutableArray<TypeDefinitionHandle>.Empty; }
public UnificationKey(MetadataReader reader, TypeDefinitionHandle typeDefinitionHandle, GenericParameterHandle genericParameterHandle) { _reader = reader; _typeDefinitionHandle = typeDefinitionHandle; _genericParameterHandle = genericParameterHandle; }
private uint GetTypeDefTreatmentAndRowId(TypeDefinitionHandle handle) { // PERF: This code pattern is JIT friendly and results in very efficient code. if (this.metadataKind == MetadataKind.Ecma335) { return handle.RowId; } return CalculateTypeDefTreatmentAndRowId(handle); }
public static bool TryGetMethodMetadataFromStartAddress(IntPtr methodStartAddress, out MetadataReader reader, out TypeDefinitionHandle typeHandle, out MethodHandle methodHandle) { reader = null; typeHandle = default(TypeDefinitionHandle); methodHandle = default(MethodHandle); RuntimeTypeHandle declaringTypeHandle = default(RuntimeTypeHandle); if (!ExecutionEnvironment.TryGetMethodForOriginalLdFtnResult(methodStartAddress, ref declaringTypeHandle, out QMethodDefinition qMethodDefinition, out _)) { return(false); } if (!qMethodDefinition.IsNativeFormatMetadataBased) { return(false); } if (RuntimeAugments.IsGenericType(declaringTypeHandle)) { declaringTypeHandle = RuntimeAugments.GetGenericDefinition(declaringTypeHandle); } if (!ExecutionEnvironment.TryGetMetadataForNamedType(declaringTypeHandle, out QTypeDefinition qTypeDefinition)) { return(false); } Debug.Assert(qTypeDefinition.IsNativeFormatMetadataBased); Debug.Assert(qTypeDefinition.NativeFormatReader == qMethodDefinition.NativeFormatReader); reader = qTypeDefinition.NativeFormatReader; typeHandle = qTypeDefinition.NativeFormatHandle; methodHandle = qMethodDefinition.NativeFormatHandle; return(true); }