/// <summary> /// Creates a new reference to a member in an (external) .NET assembly. /// </summary> /// <param name="parent">The declaring member that defines the referenced member.</param> /// <param name="name">The name of the referenced member.</param> /// <param name="signature">The signature of the referenced member. This dictates whether the /// referenced member is a field or a method.</param> public MemberReference(IMemberRefParent parent, string name, MemberSignature signature) : this(new MetadataToken(TableIndex.MemberRef, 0)) { Parent = parent; Name = name; Signature = signature; }
public MemberReference(IMemberRefParent parent, string name, MemberSignature signature) : base(null, new MetadataToken(MetadataTokenType.MemberRef), new MetadataRow <uint, uint, uint>()) { _parent = new LazyValue <IMemberRefParent>(parent); _name = new LazyValue <string>(name); _signature = new LazyValue <MemberSignature>(signature); }
protected override Action <ITextControl> ExecutePsiTransaction(ISolution solution, IProgressIndicator progress) { ITypeDeclaration typeDeclaration = GetTargetTypeDeclaration(_highlighting.BaseClass); if (typeDeclaration == null) { return(null); } MemberSignature signature = CreateTransformTextSignature(typeDeclaration); TypeTarget target = CreateTarget(typeDeclaration); var context = new CreateMethodDeclarationContext { AccessRights = AccessRights.PUBLIC, ExecuteTemplateOverMemberBody = false, ExecuteTemplateOverName = false, ExecuteTemplateOverParameters = false, ExecuteTemplateOverReturnType = false, IsAbstract = true, IsStatic = false, MethodSignatures = new[] { signature }, MethodName = T4CSharpIntermediateConverterBase.TransformTextMethodName, SourceReferenceExpressionReference = null, Target = target, }; IntentionResult intentionResult = MethodDeclarationBuilder.Create(context); intentionResult.ExecuteTemplate(); return(null); }
public override bool Equals(object obj) { MemberSignature memberSignature = obj as MemberSignature; if ((memberSignature == null) || (this.name != memberSignature.Name) || (this.returnType != memberSignature.ReturnType)) { return(false); } if ((this.Parameters == null) && (memberSignature.Parameters != null) || (this.Parameters != null) && (memberSignature.Parameters == null)) { return(false); } if (this.Parameters != null) { if (this.parameters.Length != memberSignature.parameters.Length) { return(false); } for (int loop = 0; loop < this.parameters.Length; loop++) { if (this.parameters[loop] != memberSignature.parameters[loop]) { return(false); } } } return(true); }
internal void AddMethod(ContractMethodInfo methodInfo) { if (methodInfo == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("methodInfo"); } MemberSignature signature = new MemberSignature(methodInfo); if (this.GetMemberHelper <MethodInfo>(BindingFlags.Public | BindingFlags.Instance, signature, ref this.methods) != null) { return; } else { List <MethodInfo> localMethods = new List <MethodInfo>(); if (this.methods != null) { localMethods.AddRange(this.methods); } localMethods.Add(methodInfo); this.methods = new MethodInfo[localMethods.Count]; localMethods.CopyTo(this.methods); } }
public MemberReference(IMemberRefParent parent, string name, MemberSignature signature) : base(new MetadataToken(MetadataTokenType.MemberRef)) { _parent = new LazyValue <IMemberRefParent>(parent); _name = new LazyValue <string>(name); _signature = new LazyValue <MemberSignature>(signature); CustomAttributes = new CustomAttributeCollection(this); }
// generic method that implements all GetXXXs methods private T[] GetMembersHelper <T>(BindingFlags bindingAttr, ref T[] members, bool searchBase) where T : MemberInfo { Dictionary <MemberSignature, T> membersDictionary = new Dictionary <MemberSignature, T>(); if (members != null) { // get local properties foreach (T memberInfo in members) { MemberSignature memberSignature = new MemberSignature(memberInfo); if ((FilterMember(memberInfo, bindingAttr)) && (!membersDictionary.ContainsKey(memberSignature))) { membersDictionary.Add(new MemberSignature(memberInfo), memberInfo); } } } if (searchBase && (bindingAttr & BindingFlags.DeclaredOnly) == 0) { // FlattenHierarchy is required to return static members from base classes. if ((bindingAttr & BindingFlags.FlattenHierarchy) == 0) { bindingAttr &= ~BindingFlags.Static; } // Type baseType = BaseType; // if (baseType != null) // { // T[] baseMembers = GetBaseMembers(typeof(T), baseType, bindingAttr) as T[]; // foreach (T memberInfo in baseMembers) // { // // We should not return private members from base classes. Note: Generics requires us to use "as". // if ((memberInfo is FieldInfo && (memberInfo as FieldInfo).IsPrivate) || (memberInfo is MethodBase && (memberInfo as MethodBase).IsPrivate) || (memberInfo is Type && (memberInfo as Type).IsNestedPrivate)) // { // continue; // } // // verify a member with this signature was not already created // MemberSignature memberSignature = new MemberSignature(memberInfo); // if (!membersDictionary.ContainsKey(memberSignature)) // { // membersDictionary.Add(memberSignature, memberInfo); // } // } // } } List <T> memberCollection = new List <T>(membersDictionary.Values); return(memberCollection.ToArray()); }
private static void VerifyMatching(MemberSignature original, MemberSignature expected, params MemberSignature[] fails) { Assert.IsTrue(_comparer.MatchMemberSignatures(original, expected), "The original signature did not match the expected."); Assert.IsTrue(_comparer.MatchMemberSignatures(expected, original), "The expected signature did not match the original."); foreach (var fail in fails) { Assert.IsFalse(_comparer.MatchMemberSignatures(original, fail), original + " matched " + fail); Assert.IsFalse(_comparer.MatchMemberSignatures(fail, original), fail + " matched " + original); } }
/// <inheritdoc /> public MemberSignature ImportMemberSignature(MemberSignature signature) { switch (signature) { case FieldSignature fieldSignature: return(ImportFieldSignature(fieldSignature)); case MethodSignature methodSignature: return(ImportMethodSignature(methodSignature)); default: throw new NotSupportedException(); } }
private T[] GetMembersHelper <T>(BindingFlags bindingAttr, MemberSignature memberSignature, ref T[] members) where T : MemberInfo { List <T> memberCandidates = new List <T>(); foreach (T memberInfo in this.GetMembersHelper <T>(bindingAttr, ref members, true)) { MemberSignature candididateMemberSignature = new MemberSignature(memberInfo); if (candididateMemberSignature.FilterSignature(memberSignature)) { memberCandidates.Add(memberInfo); } } return(memberCandidates.ToArray()); }
//private MemberInfo[] GetBaseMembers(Type type, Type baseType, BindingFlags bindingAttr) //{ // MemberInfo[] members = null; // if (type == typeof(PropertyInfo)) // { // members = baseType.GetProperties(bindingAttr); // } // else if (type == typeof(EventInfo)) // { // members = baseType.GetEvents(bindingAttr); // } // else if (type == typeof(ConstructorInfo)) // { // members = baseType.GetConstructors(bindingAttr); // } // else if (type == typeof(MethodInfo)) // { // members = baseType.GetMethods(bindingAttr); // } // else if (type == typeof(FieldInfo)) // { // members = baseType.GetFields(bindingAttr); // } // else if (type == typeof(Type)) // { // members = baseType.GetNestedTypes(bindingAttr); // } // return members; //} // generic method that implements all GetXXX methods private T GetMemberHelper <T>(BindingFlags bindingAttr, MemberSignature memberSignature, ref T[] members) where T : MemberInfo { if (members != null) { // search the local type foreach (T memberInfo in members) { MemberSignature candididateMemberSignature = new MemberSignature(memberInfo); if (candididateMemberSignature.FilterSignature(memberSignature) && FilterMember(memberInfo, bindingAttr)) { return(memberInfo); } } } return(null); }
public MemberSignature ImportMemberSignature(MemberSignature signature) { var fieldSignature = signature as FieldSignature; if (fieldSignature != null) { return(ImportFieldSignature(fieldSignature)); } var methodSignature = signature as MethodSignature; if (methodSignature != null) { return(ImportMethodSignature(methodSignature)); } throw new NotSupportedException(); }
internal static void RegisterDeclaredEntity(IEntity entity, MemberSignature member) { switch (member) { case FieldSignature field: fieldSignatureCache.Add((IField)entity, field); break; case MethodSignature method: methodSignatureCache.Add((IMethod)entity, method); break; case PropertySignature property: propSignatureCache.Add((IProperty)entity, property); break; case TypeSignature type: typeSignatureCache.Add((ITypeDefinition)entity, type); break; default: throw new NotSupportedException($"{member.GetType()} {entity.GetType()}"); } }
// this method will filter using a mask signautre. only non-null mask members are used to filter // the signature, the rest are ignored public bool FilterSignature(MemberSignature maskSignature) { if (maskSignature == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("maskSignature"); } if (((maskSignature.Name != null) && (this.name != maskSignature.name)) || ((maskSignature.returnType != null) && (this.returnType != maskSignature.returnType))) { return(false); } if (maskSignature.parameters != null) { if (this.parameters == null) { return(false); } if (this.parameters.Length != maskSignature.parameters.Length) { return(false); } for (int loop = 0; loop < this.parameters.Length; loop++) { if (!this.parameters[loop].Equals(maskSignature.parameters[loop])) { return(false); } } } return(true); }
/// <summary> Gets declaring type of the specified member. It is has no declaring type (e.g. a type in namespace), `null` is returned. </summary> public static TypeSignature DeclaringType(this MemberSignature member) => member switch {
public static bool IsSpecial(MemberSignature m) => (m as MethodSignature)?.HasSpecialName == true || m.Name.StartsWith("<");