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
}
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);
}
/// <summary>
/// We want to know if a given method implements a redirected interface.
/// For example, if we are given the method RemoveAt on a class "A"
/// which implements the IVector interface (which is redirected
/// to IList in .NET) then this method would return true. The most
/// likely reason why we would want to know this is that we wish to hide
/// (mark private) all methods which implement methods on a redirected
/// interface.
/// </summary>
/// <param name="memberRef">The declaration token for the method</param>
/// <param name="isIDisposable">
/// Returns true if the redirected interface is <see cref="IDisposable"/>.
/// </param>
/// <returns>True if the method implements a method on a redirected interface.
/// False otherwise.</returns>
private bool ImplementsRedirectedInterface(MemberReferenceHandle memberRef, out bool isIDisposable)
{
isIDisposable = false;
MetadataToken parent = peFileReader.GetMemberReference((MemberReferenceHandle)memberRef).Parent;
TypeReferenceHandle typeRef;
if (parent.HandleType == HandleType.TypeReference)
{
typeRef = (TypeReferenceHandle)parent;
}
else if (parent.HandleType == HandleType.TypeSpecification)
{
BlobHandle blob = peFileReader.GetTypeSpecification((TypeSpecificationHandle)parent);
MemoryBlock sigBlock = peFileReader.BlobStream.GetMemoryBlockAt(blob);
if (sigBlock.Length < 2)
{
return(false);
}
MemoryReader sig = new MemoryReader(sigBlock);
if (sig.ReadByte() != (byte)CorElementType.ELEMENT_TYPE_GENERICINST ||
sig.ReadByte() != (byte)CorElementType.ELEMENT_TYPE_CLASS)
{
return(false);
}
MetadataToken token = SignatureHelpers.DecodeToken(ref sig);
if (token.HandleType != HandleType.TypeReference)
{
return(false);
}
typeRef = (TypeReferenceHandle)token;
}
else
{
return(false);
}
TypeReference reference = peFileReader.GetTypeReference(typeRef);
if (reference.Namespace.IsNil)
{
return(false);
}
string name = peFileReader.StringStream[reference.Name];
string @namespace = peFileReader.StringStream[reference.Namespace];
return(WinRTProjectedTypes.IsWinRTTypeReference(name, @namespace, out isIDisposable));
}
