예제 #1
0
        bool IsAppropriateCallTarget(ExpectedTargetDetails expectedTargetDetails, IMember expectedTarget, IMember actualTarget)
        {
            if (expectedTarget.Equals(actualTarget))
            {
                return(true);
            }

            if (expectedTargetDetails.CallOpCode == OpCode.CallVirt && actualTarget.IsOverride)
            {
                if (expectedTargetDetails.NeedsBoxingConversion && actualTarget.DeclaringType.IsReferenceType != true)
                {
                    return(false);
                }
                foreach (var possibleTarget in InheritanceHelper.GetBaseMembers(actualTarget, false))
                {
                    if (expectedTarget.Equals(possibleTarget))
                    {
                        return(true);
                    }
                    if (!possibleTarget.IsOverride)
                    {
                        break;
                    }
                }
            }
            return(false);
        }
예제 #2
0
        private static void DuplicateMemberReferencesAreEqual([NotNull] IMember originMember,
                                                              [NotNull] IMember memberReferenceDuplicate)
        {
            originMember.RequiredNotNull();
            memberReferenceDuplicate.RequiredNotNull();

            Assert.True(originMember.Equals(memberReferenceDuplicate));
        }
        protected override void Run(object data)
        {
            Document doc = IdeApp.Workbench.ActiveDocument;

            if (doc == null || doc.FileName == FilePath.Null || IdeApp.ProjectOperations.CurrentSelectedSolution == null)
            {
                return;
            }
            ITextBuffer editor = doc.GetContent <ITextBuffer> ();

            if (editor == null)
            {
                return;
            }
            int line, column;

            editor.GetLineColumnFromPosition(editor.CursorPosition, out line, out column);
            ProjectDom ctx = doc.Dom;

            ResolveResult resolveResult;
            INode         item;

            CurrentRefactoryOperationsHandler.GetItem(ctx, doc, editor, out resolveResult, out item);
            IMember eitem    = resolveResult != null ? (resolveResult.CallingMember ?? resolveResult.CallingType) : null;
            string  itemName = null;

            if (item is IMember)
            {
                itemName = ((IMember)item).Name;
            }
            if (item != null && eitem != null && (eitem.Equals(item) || (eitem.Name == itemName && !(eitem is IProperty) && !(eitem is IField) && !(eitem is IMethod))))
            {
                item  = eitem;
                eitem = null;
            }

            IType eclass = null;

            if (item is IType)
            {
                if (((IType)item).ClassType == ClassType.Interface)
                {
                    eclass = CurrentRefactoryOperationsHandler.FindEnclosingClass(ctx, editor.Name, line, column);
                }
                else
                {
                    eclass = (IType)item;
                }
                if (eitem is IMethod && ((IMethod)eitem).IsConstructor && eitem.DeclaringType.Equals(item))
                {
                    item  = eitem;
                    eitem = null;
                }
            }
            Refactorer refactorer = new Refactorer(ctx, doc.CompilationUnit, eclass, item, null);

            refactorer.GoToDeclaration();
        }
예제 #4
0
 static bool IsSameMember(IMember a, IMember b)
 {
     if (a == null || b == null)
     {
         return(false);
     }
     a = a.MemberDefinition;
     b = b.MemberDefinition;
     return(a.Equals(b));
 }
예제 #5
0
        bool IsAppropriateCallTarget(IMember expectedTarget, IMember actualTarget, bool isVirtCall)
        {
            if (expectedTarget.Equals(actualTarget))
            {
                return(true);
            }

            if (isVirtCall && actualTarget.IsOverride)
            {
                foreach (var possibleTarget in InheritanceHelper.GetBaseMembers(actualTarget, false))
                {
                    if (expectedTarget.Equals(possibleTarget))
                    {
                        return(true);
                    }
                    if (!possibleTarget.IsOverride)
                    {
                        break;
                    }
                }
            }
            return(false);
        }
예제 #6
0
 bool IsMemberMatch(IMember member, IMember referencedMember, bool isVirtualCall)
 {
     referencedMember = NormalizeMember(referencedMember);
     if (member.Equals(referencedMember))
         return true;
     if (!isVirtualCall)
         return false;
     bool isInterfaceCall = referencedMember.DeclaringTypeDefinition != null && referencedMember.DeclaringTypeDefinition.Kind == TypeKind.Interface;
     if (FindCallsThroughVirtualBaseMethod && member.IsOverride && !WholeVirtualSlot && !isInterfaceCall) {
         // Test if 'member' overrides 'referencedMember':
         foreach (var baseMember in InheritanceHelper.GetBaseMembers(member, false)) {
             if (FindOnlySpecializedReferences) {
                 if (baseMember.Equals(referencedMember))
                     return true;
             } else {
                 if (baseMember.MemberDefinition.Equals(referencedMember))
                     return true;
             }
             if (!baseMember.IsOverride)
                 break;
         }
         return false;
     } else if (FindCallsThroughInterface && isInterfaceCall) {
         // Test if 'member' implements 'referencedMember':
         if (FindOnlySpecializedReferences) {
             return member.ImplementedInterfaceMembers.Contains(referencedMember);
         } else {
             return member.ImplementedInterfaceMembers.Any(m => m.MemberDefinition.Equals(referencedMember));
         }
     }
     return false;
 }
        public IMember Resolve(ITypeResolveContext context)
        {
            IType   declaringType   = typeReference.Resolve(context);
            IMember interfaceMember = interfaceMemberReference.Resolve(context.WithCurrentTypeDefinition(declaringType.GetDefinition()));

            if (interfaceMember == null)
            {
                return(null);
            }
            IEnumerable <IMember> members;

            if (interfaceMember.SymbolKind == SymbolKind.Accessor)
            {
                members = declaringType.GetAccessors(
                    m => m.IsExplicitInterfaceImplementation,
                    GetMemberOptions.IgnoreInheritedMembers);
            }
            else
            {
                members = declaringType.GetMembers(
                    m => m.SymbolKind == interfaceMember.SymbolKind && m.IsExplicitInterfaceImplementation,
                    GetMemberOptions.IgnoreInheritedMembers);
            }
            return(members.FirstOrDefault(m => m.ImplementedInterfaceMembers.Count == 1 && interfaceMember.Equals(m.ImplementedInterfaceMembers[0])));
        }
예제 #8
0
        private void AddMissingAliases(TypeDeclaration typeDeclaration)
        {
            var type       = this.Resolver.ResolveNode(typeDeclaration, null).Type;
            var interfaces = type.DirectBaseTypes.Where(t => t.Kind == TypeKind.Interface).ToArray();
            var members    = type.GetMembers(null, GetMemberOptions.IgnoreInheritedMembers).ToArray();
            var baseTypes  = type.GetNonInterfaceBaseTypes().ToArray().Reverse();

            if (interfaces.Length > 0)
            {
                foreach (var baseInterface in interfaces)
                {
                    var interfaceMembers = baseInterface.GetMembers().Where(m => m.DeclaringTypeDefinition.Kind == TypeKind.Interface);
                    foreach (var interfaceMember in interfaceMembers)
                    {
                        var isDirectlyImplemented = members.Any(m => m.ImplementedInterfaceMembers.Contains(interfaceMember));
                        if (!isDirectlyImplemented)
                        {
                            foreach (var baseType in baseTypes)
                            {
                                //var derivedMember = InheritanceHelper.GetDerivedMember(interfaceMember, baseType.GetDefinition());
                                IMember derivedMember = null;
                                IEnumerable <IMember> baseMembers;
                                if (interfaceMember.SymbolKind == SymbolKind.Accessor)
                                {
                                    baseMembers = baseType.GetAccessors(null, GetMemberOptions.IgnoreInheritedMembers).Where(m => m.Name == interfaceMember.Name && TypeComparer.Equals(m.ReturnType, interfaceMember.ReturnType));
                                }
                                else
                                {
                                    baseMembers = baseType.GetMembers(null, GetMemberOptions.IgnoreInheritedMembers).Where(m => m.Name == interfaceMember.Name && TypeComparer.Equals(m.ReturnType, interfaceMember.ReturnType));
                                }

                                foreach (IMember baseMember in baseMembers)
                                {
                                    if (baseMember.IsPrivate)
                                    {
                                        continue;
                                    }
                                    if (SignatureComparer.Ordinal.Equals(interfaceMember, baseMember))
                                    {
                                        derivedMember = baseMember.Specialize(interfaceMember.Substitution);
                                        break;
                                    }
                                }

                                if (derivedMember != null && !derivedMember.ImplementedInterfaceMembers.Contains(interfaceMember) && !this.CurrentType.InstanceConfig.Alias.Any(a => typeDeclaration.Equals(a.Entity) && interfaceMember.Equals(a.InterfaceMember) && derivedMember.Equals(a.DerivedMember)))
                                {
                                    this.CurrentType.InstanceConfig.Alias.Add(new TypeConfigItem {
                                        Entity = typeDeclaration, InterfaceMember = interfaceMember, DerivedMember = derivedMember
                                    });
                                    break;
                                }
                            }
                        }
                    }
                }
            }
        }
예제 #9
0
        public IMember Resolve(ITypeResolveContext context)
        {
            IMember interfaceMember = interfaceMemberReference.Resolve(context);

            if (interfaceMember == null)
            {
                return(null);
            }
            IType type    = typeReference.Resolve(context);
            var   members = type.GetMembers(
                m => m.EntityType == interfaceMember.EntityType && m.IsExplicitInterfaceImplementation,
                GetMemberOptions.IgnoreInheritedMembers);

            return(members.FirstOrDefault(m => m.InterfaceImplementations.Count == 1 && interfaceMember.Equals(m.InterfaceImplementations[0])));
        }
예제 #10
0
        private static void MemberDoesNotEqualNull([NotNull] IMember member)
        {
            member.RequiredNotNull();

            Assert.False(member.Equals(null));
        }
        public IMember Resolve(ITypeResolveContext context)
        {
            IType   declaringType   = typeReference.Resolve(context);
            IMember interfaceMember = interfaceMemberReference.Resolve(context.WithCurrentTypeDefinition(declaringType.GetDefinition()));

            if (interfaceMember == null)
            {
                return(null);
            }
            var members = declaringType.GetMembers(
                m => m.EntityType == interfaceMember.EntityType && m.IsExplicitInterfaceImplementation,
                GetMemberOptions.IgnoreInheritedMembers);

            return(members.FirstOrDefault(m => m.ImplementedInterfaceMembers.Count == 1 && interfaceMember.Equals(m.ImplementedInterfaceMembers[0])));
        }