public string GetMemberSignature(ITypeMemberReference member, bool TypeMemberPrefix)
{
string sig;
IFieldReference typeRef = member as IFieldReference;
if (typeRef != null) // CCI change where now fields Signature contains return type.
sig = GetMemberSignature(member, FieldFormatOpts);
else
sig = GetMemberSignature(member, FormatOpts);
IMethodReference method = member as IMethodReference;
if (method != null && sig.Contains("()")) // CCI change where parameterless methods now return empty parenthesis.
{
sig = sig.Replace("()", "");
}
IPropertyDefinition property = member as IPropertyDefinition;
if (property != null)
{
sig = sig.Replace("[", "(").Replace("]", ")");
}
if (TypeMemberPrefix)
{
string prefix = Enum.GetName(typeof(MemberTypes), TypeMemberType(member));
return prefix + " : " + sig;
}
else
{
return sig;
}
}
private static MemberTypes TypeMemberType(ITypeMemberReference member)
{
if (member is IMethodReference)
return MemberTypes.Method;
else if (member is IFieldReference)
return MemberTypes.Field;
else if (member is IPropertyDefinition)
return MemberTypes.Property;
else if (member is IEventDefinition)
return MemberTypes.Event;
else
return MemberTypes.Unknown;
}
public static ITypeDefinitionMember ResolveMemberThrowing(ITypeMemberReference memberRef)
{
ITypeDefinitionMember result = memberRef.ResolvedTypeDefinitionMember;
if (result == Dummy.Method ||
result == Dummy.Field ||
result == Dummy.Event ||
result == Dummy.Property ||
result == null)
{
throw new Exception(String.Format("Cannot resolve member '{0}'. Are all dependent assemblies loaded?", memberRef.ToString()));
}
Debug.Assert(!result.GetType().Name.Contains("Dummy"));
return result;
}
internal SignatureConverter(
PEFileToObjectModel peFileToObjectModel,
MemoryReader signatureMemoryReader,
MetadataObject metadataOwnerObject
)
//^ requires signatureMemoryReader.Length > 0;
{
this.PEFileToObjectModel = peFileToObjectModel;
this.SignatureMemoryReader = signatureMemoryReader;
this.MetadataOwnerObject = metadataOwnerObject;
this.ModuleMethodReference = metadataOwnerObject as IMethodReference;
this.ModuleMemberReference = metadataOwnerObject as ITypeMemberReference;
TypeMember/*?*/ moduleTypeMember = metadataOwnerObject as TypeMember;
if (moduleTypeMember != null) {
this.ModuleGenericType = moduleTypeMember.ContainingTypeDefinition as TypeBase;
this.ModuleGenericMethod = moduleTypeMember as GenericMethod;
return;
}
var moduleGenericType = metadataOwnerObject as TypeBase;
if (moduleGenericType != null) {
this.ModuleGenericType = moduleGenericType;
return;
}
GenericTypeParameter/*?*/ genericTypeParam = metadataOwnerObject as GenericTypeParameter;
if (genericTypeParam != null) {
this.ModuleGenericType = genericTypeParam.OwningGenericType;
return;
}
GenericMethodParameter/*?*/ genericMethodParam = metadataOwnerObject as GenericMethodParameter;
if (genericMethodParam != null) {
this.ModuleGenericType = genericMethodParam.OwningGenericMethod.ContainingTypeDefinition as TypeBase;
this.ModuleGenericMethod = genericMethodParam.OwningGenericMethod;
return;
}
}
public override void Visit(ITypeMemberReference member)
{
// The member can resolve to an external assembly, so we need to check whether we can include the external assembly.
INamedTypeReference containingType = Util.CanonicalizeType(Util.CanonicalizeMemberReference(member).ContainingType);
if (m_implModel.CanInclude(containingType))
{
AddTypeReference(containingType);
if (member != null)
{
AddMemberReference(Util.CanonicalizeMember(member));
return;
}
}
}
/// <summary>
/// Visits the specified type member reference.
/// </summary>
public virtual void Visit(ITypeMemberReference typeMember)
{
Contract.Requires(typeMember != null);
}
public virtual void Visit(ITypeMemberReference typeMemberReference)
{
if (typeMemberReference.AsDefinition(Context) == null)
{
this.Visit(typeMemberReference.GetAttributes(Context)); // In principle, references can have attributes that are distinct from the definitions they refer to.
}
}
protected override void RecordTypeMemberReference(ITypeMemberReference typeMemberReference)
{
this.metadataWriter.GetMemberRefIndex(typeMemberReference);
}
/// <summary>
/// Visits the specified type member reference.
/// </summary>
public void Visit(ITypeMemberReference typeMember)
{
var resolvedReference = typeMember.ResolvedTypeDefinitionMember;
if (!(resolvedReference is Dummy) && typeMember != resolvedReference) {
if (resolvedReference.Visibility == TypeMemberVisibility.Other)
this.ReportError(MetadataError.ReferenceToTypeMemberWithOtherVisibility, typeMember, resolvedReference);
}
}
public static bool IsWindowsRuntimeMember(this ITypeMemberReference member)
{
IAssemblyReference assemblyRef = member.GetAssemblyReference();
return(assemblyRef.IsWindowsRuntimeAssembly());
}
public static string MemberKeyFromMember(ITypeMemberReference member)
{
return(MemberNameFromMember(member));//nameBuilder.ToString();
}
public static string MemberNameFromMember(ITypeMemberReference member)
{
return(GetMemberSignature(member));
}
public static ITypeMemberReference CanonicalizeMemberReference(ITypeMemberReference member)
{
if (null == member)
{
return(null);
}
if (member == null || member == Dummy.Method)
{
throw new Exception("Can't resolve member");
}
// function pointers don't have declaring types and they don't
// really fit our model, so we ignore them.
if (null == member.ContainingType)
{
return(null);
}
//
// first canonicalize the method...
//
IGenericMethodInstanceReference genMeth = member as IGenericMethodInstanceReference;
if ((genMeth != null))
{
member = genMeth.GenericMethod;
}
ISpecializedMethodReference specializedMethodRef = member as ISpecializedMethodReference;
ISpecializedFieldReference specializedFieldRef = member as ISpecializedFieldReference;
ISpecializedPropertyDefinition specializedPropertyDef = member as ISpecializedPropertyDefinition;
ISpecializedEventDefinition specializedEventDef = member as ISpecializedEventDefinition;
ISpecializedMethodDefinition specializedMethodDef = member as ISpecializedMethodDefinition;
ISpecializedFieldDefinition specializedFieldDef = member as ISpecializedFieldDefinition;
if (specializedMethodRef != null)
{
member = specializedMethodRef.UnspecializedVersion;
}
else if (specializedFieldRef != null)
{
member = specializedFieldRef.UnspecializedVersion;
}
else if (specializedPropertyDef != null)
{
member = specializedPropertyDef.UnspecializedVersion;
}
else if (specializedEventDef != null)
{
member = specializedEventDef.UnspecializedVersion;
}
else if (specializedMethodDef != null)
{
member = specializedMethodDef.UnspecializedVersion;
}
else if (specializedFieldDef != null)
{
member = specializedFieldDef.UnspecializedVersion;
}
if (member == null)
{
throw new Exception("Can't canonicalize some member.");
}
return(member);
}
public static string GetMemberSignature(ITypeMemberReference member)
{
return((new ModelSigFormatter()).GetMemberSignature(member, true));
}
public static string GetMemberSignature(ITypeMemberReference member, bool MemberTypePrefix)
{
return((new ModelSigFormatter()).GetMemberSignature(member, MemberTypePrefix));
}
/// <summary>
/// Returns a C#-like string that corresponds to the given type member definition and that conforms to the specified formatting options.
/// </summary>
//^ [Pure]
public static string GetMemberSignature(ITypeMemberReference member, NameFormattingOptions formattingOptions)
{
return(new SignatureFormatter().GetMemberSignature(member, formattingOptions));
}
public override void Visit(ITypeMemberReference typeMember)
{
allElements.Add(new InvokInfo(Traverser, "ITypeMemberReference", typeMember));
}
/// <summary>
/// Visits the specified type member reference.
/// </summary>
public virtual void Visit(ITypeMemberReference typeMember)
{
}
public static ITypeDefinitionMember CanonicalizeMember(ITypeMemberReference member)
{
return(ResolveMemberThrowing(CanonicalizeMemberReference(member)));
}
protected override void RecordTypeMemberReference(ITypeMemberReference typeMemberReference)
{
this.metadataWriter.GetMemberRefIndex(typeMemberReference);
}
/// <summary>
/// Visits the specified type member reference.
/// </summary>
public virtual void Visit(ITypeMemberReference typeMember)
{
Contract.Requires(typeMember != null);
}
private void Traverse(ITypeMemberReference typeMemberReference) {
Contract.Requires(typeMemberReference != null);
typeMemberReference.DispatchAsReference(this.dispatchingVisitor);
}
public virtual TrimMember GetMemberElementFromMember(ITypeMemberReference member)
{
if (member == null || member.GetType().ToString().Contains("Dummy"))
{ throw new ArgumentNullException("member"); }
MemberElement memberElement = null;
_typeMembers.TryGetValue(Util.MemberKeyFromMember(member), out memberElement);
return memberElement as TrimMember;
}
public override void Visit(ITypeMemberReference typeMember) {
typeMember.ResolvedTypeDefinitionMember.Dispatch(this);
}
public override void Visit(ITypeMemberReference typeMemberReference)
{
RecordTypeMemberReference(typeMemberReference);
//This code was in CCI, but appears wrong to me. There is no need to visit attributes of members that are
//being referenced, only those being defined. This code causes additional spurious typerefs and memberrefs to be
//emitted. If the attributes can't be resolved, it causes a NullReference.
//
//if ((typeMemberReference.AsDefinition(Context) == null))
//{
// this.Visit(typeMemberReference.GetAttributes(Context));
//}
this.typeReferenceNeedsToken = true;
this.Visit(typeMemberReference.GetContainingType(Context));
Debug.Assert(!this.typeReferenceNeedsToken);
}
protected abstract void RecordTypeMemberReference(ITypeMemberReference typeMemberReference);
protected override void RecordTypeMemberReference(ITypeMemberReference typeMemberReference)
{
}
protected override void RecordTypeMemberReference(ITypeMemberReference typeMemberReference)
{
}
public override TrimMember GetMemberElementFromMember(ITypeMemberReference member)
{
return(new SpecialTrimMember(this, member.Name.Value, null, Util.GetMemberTypeFromMember(member)));
}
public override TrimMember GetMemberElementFromMember(ITypeMemberReference member)
{
return new SpecialTrimMember(this, member.Name.Value, null, Util.GetMemberTypeFromMember(member));
}
public static string GetMemberSignature(ITypeMemberReference member, bool MemberTypePrefix)
{
return (new ModelSigFormatter()).GetMemberSignature(member, MemberTypePrefix);
}
protected abstract void RecordTypeMemberReference(ITypeMemberReference typeMemberReference);
public static ITypeMemberReference CanonicalizeMemberReference(ITypeMemberReference member)
{
if (null == member)
return null;
if (member == null || member == Dummy.Method)
throw new Exception("Can't resolve member");
// function pointers don't have declaring types and they don't
// really fit our model, so we ignore them.
if (null == member.ContainingType)
return null;
//
// first canonicalize the method...
//
IGenericMethodInstanceReference genMeth = member as IGenericMethodInstanceReference;
if ((genMeth != null))
{
member = genMeth.GenericMethod;
}
ISpecializedMethodReference specializedMethodRef = member as ISpecializedMethodReference;
ISpecializedFieldReference specializedFieldRef = member as ISpecializedFieldReference;
ISpecializedPropertyDefinition specializedPropertyDef = member as ISpecializedPropertyDefinition;
ISpecializedEventDefinition specializedEventDef = member as ISpecializedEventDefinition;
ISpecializedMethodDefinition specializedMethodDef = member as ISpecializedMethodDefinition;
ISpecializedFieldDefinition specializedFieldDef = member as ISpecializedFieldDefinition;
if (specializedMethodRef != null)
member = specializedMethodRef.UnspecializedVersion;
else if (specializedFieldRef != null)
member = specializedFieldRef.UnspecializedVersion;
else if (specializedPropertyDef != null)
member = specializedPropertyDef.UnspecializedVersion;
else if (specializedEventDef != null)
member = specializedEventDef.UnspecializedVersion;
else if (specializedMethodDef != null)
member = specializedMethodDef.UnspecializedVersion;
else if (specializedFieldDef != null)
member = specializedFieldDef.UnspecializedVersion;
if (member == null)
throw new Exception("Can't canonicalize some member.");
return member;
}
public static MemberTypes GetMemberTypeFromMember(ITypeMemberReference member)
{
if (member is IMethodReference)
return MemberTypes.Method;
else if (member is IFieldReference)
return MemberTypes.Field;
else if (member is IPropertyDefinition)
return MemberTypes.Property;
else if (member is IEventDefinition)
return MemberTypes.Event;
else if (member is ITypeReference)
return MemberTypes.Type;
else
return MemberTypes.Unknown;
}
public static string GetMemberSignature(ITypeMemberReference member)
{
return (new ModelSigFormatter()).GetMemberSignature(member, true);
}
protected override MemberReferenceHandle GetOrAddMemberReferenceHandle(ITypeMemberReference reference)
{
return(MetadataTokens.MemberReferenceHandle(_memberRefIndex.GetOrAdd(reference)));
}
public static string MemberKeyFromMember(ITypeMemberReference member)
{
return MemberNameFromMember(member);//nameBuilder.ToString();
}
/// <summary>
/// Visits the specified type member reference.
/// </summary>
/// <param name="typeMemberReference">The type member reference.</param>
public virtual void Visit(ITypeMemberReference typeMemberReference)
{
if (this.stopTraversal) return;
//^ int oldCount = this.path.Count;
this.path.Push(typeMemberReference);
if (!(typeMemberReference is IDefinition))
this.Visit(typeMemberReference.Attributes); //In principle, refererences can have attributes that are distinct from the definitions they refer to.
//^ assume this.path.Count == oldCount+1; //True because all of the virtual methods of this class promise not decrease this.path.Count.
this.path.Pop();
}
public static string MemberNameFromMember(ITypeMemberReference member)
{
return GetMemberSignature(member);
}
protected override uint GetOrAddMemberRefIndex(ITypeMemberReference reference)
{
return(this.memberRefIndex.GetOrAdd(reference));
}
public static ITypeDefinitionMember CanonicalizeMember(ITypeMemberReference member)
{
return ResolveMemberThrowing(CanonicalizeMemberReference(member));
}
public override ITypeMemberDefinition ResolveReference(ITypeMemberReference member)
{
return(base.ResolveReference(member));
}
public static string DocId(this ITypeMemberReference member)
{
// Do we need to unwrap members?
// member = member.UnWrapMember();
return(MemberHelper.GetMemberSignature(member, NameFormattingOptions.DocumentationId));
}
public void AddMemberReference(ITypeMemberReference member)
{
if (null == member)
return;
ITypeDefinitionMember memberDef = Util.CanonicalizeMember(member);
if (memberDef == Dummy.Method ||
memberDef == Dummy.Field ||
memberDef == Dummy.Property ||
memberDef == Dummy.Event ||
memberDef == Dummy.Type)
throw new Exception("Cannot add Dummy member");
// CanonicalizeMember(ITypeDefinitionMember) ensures that member.ContainingType should always be non-null
AddTypeReference(Util.ContainingTypeDefinition(memberDef));
IMethodDefinition methodDef = memberDef as IMethodDefinition;
if (methodDef != null)
{
if (!_methodsClosure.ContainsKey(methodDef.InternedKey))
{
_methodsClosure.Add(methodDef.InternedKey, methodDef);
_workList.Enqueue(methodDef);
}
}
else
{
// TODO: Always add accessors for events and properties?
IEventDefinition eventDef = member as IEventDefinition;
IPropertyDefinition propertyDef = member as IPropertyDefinition;
if (eventDef != null)
{
foreach (IMethodReference method in eventDef.Accessors)
{
AddMemberReference(method);
}
}
if (propertyDef != null)
{
foreach (IMethodReference method in propertyDef.Accessors)
{
AddMemberReference(method);
}
}
if (!_membersClosure.ContainsKey(memberDef))
{
_membersClosure.Add(memberDef, null);
_workList.Enqueue(memberDef);
}
}
}
public override void Visit(ITypeMemberReference typeMember)
{
if(Process(typeMember)){visitor.Visit(typeMember);}
base.Visit(typeMember);
}
