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))); }
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) { }
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); }
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); }