コード例 #1
0
            public override void VisitTypeDeclaration(TypeDeclaration typeDeclaration)
            {
                if (typeDeclaration.ClassType == ClassType.Interface || typeDeclaration.ClassType == ClassType.Enum)
                {
                    return;
                }
                base.VisitTypeDeclaration(typeDeclaration);
                var rr = ctx.Resolve(typeDeclaration);

                if (rr.IsError)
                {
                    return;
                }
                foreach (var baseType in typeDeclaration.BaseTypes)
                {
                    var bt = ctx.Resolve(baseType);
                    if (bt.IsError || bt.Type.Kind != TypeKind.Interface)
                    {
                        continue;
                    }
                    bool interfaceMissing;
                    var  toImplement = ImplementInterfaceAction.CollectMembersToImplement(rr.Type.GetDefinition(), bt.Type, false, out interfaceMissing);
                    if (toImplement.Count == 0)
                    {
                        continue;
                    }

                    AddIssue(new CodeIssue(baseType, ctx.TranslateString("Missing interface member implementations"))
                    {
                        ActionProvider = { typeof(ImplementInterfaceAction), typeof(ImplementInterfaceExplicitAction) }
                    });
                }
            }
コード例 #2
0
        public static List <IMember> CollectMembersToImplement(ITypeDefinition implementingType, IType abstractType)
        {
            var  toImplement = new List <IMember>();
            bool alreadyImplemented;

            foreach (var member in abstractType.GetMembers(d => !d.IsSynthetic && d.IsAbstract))
            {
                alreadyImplemented = false;
                var allBaseTypes = member.DeclaringType.GetAllBaseTypes().ToList();
                foreach (var cmet in implementingType.GetMembers(d => d.SymbolKind == member.SymbolKind && d.Name == member.Name))
                {
                    if (allBaseTypes.Contains(cmet.DeclaringType))
                    {
                        continue;
                    }
                    if (ImplementInterfaceAction.CompareMembers(member, cmet))
                    {
                        alreadyImplemented = true;
                        break;
                    }
                }
                if (!alreadyImplemented)
                {
                    toImplement.Add(member);
                }
            }
            return(toImplement);
        }
コード例 #3
0
        public override IEnumerable <CodeAction> GetActions(RefactoringContext context)
        {
            var service = (CodeGenerationService)context.GetService(typeof(CodeGenerationService));

            if (service == null)
            {
                yield break;
            }

            var type = context.GetNode <AstType>();

            if (type == null || type.Role != Roles.BaseType)
            {
                yield break;
            }
            var state = context.GetResolverStateBefore(type);

            if (state.CurrentTypeDefinition == null)
            {
                yield break;
            }

            var resolveResult = context.Resolve(type);

            if (resolveResult.Type.Kind != TypeKind.Class || resolveResult.Type.GetDefinition() == null || !resolveResult.Type.GetDefinition().IsAbstract)
            {
                yield break;
            }

            var toImplement = CollectMembersToImplement(state.CurrentTypeDefinition, resolveResult.Type);

            if (toImplement.Count == 0)
            {
                yield break;
            }

            yield return(new CodeAction(
                             context.TranslateString("Implement abstract members"),
                             script => script.InsertWithCursor(
                                 context.TranslateString("Implement abstract members"),
                                 state.CurrentTypeDefinition, (s, c) => ImplementInterfaceAction.GenerateImplementation(c, toImplement.Select(m => Tuple.Create(m, false)), true)
                                 .Select(entity => {
                var decl = entity as EntityDeclaration;
                if (decl != null)
                {
                    decl.Modifiers |= Modifiers.Override;
                }
                return entity;
            }).ToList()), type));
        }
        public override IEnumerable <CodeAction> GetActions(RefactoringContext context)
        {
            var service = (CodeGenerationService)context.GetService(typeof(CodeGenerationService));

            if (service == null)
            {
                yield break;
            }

            var type = context.GetNode <AstType>();

            if (type == null || type.Role != Roles.BaseType)
            {
                yield break;
            }
            var state = context.GetResolverStateBefore(type);

            if (state.CurrentTypeDefinition == null)
            {
                yield break;
            }

            var resolveResult = context.Resolve(type);

            if (resolveResult.Type.Kind != TypeKind.Interface)
            {
                yield break;
            }

            bool interfaceMissing;
            var  toImplement = ImplementInterfaceAction.CollectMembersToImplement(
                state.CurrentTypeDefinition,
                resolveResult.Type,
                false,
                out interfaceMissing
                );

            if (toImplement.Count == 0)
            {
                yield break;
            }

            yield return(new CodeAction(context.TranslateString("Implement interface explicit"), script =>
                                        script.InsertWithCursor(
                                            context.TranslateString("Implement Interface"),
                                            state.CurrentTypeDefinition,
                                            (s, c) => ImplementInterfaceAction.GenerateImplementation(c, toImplement.Select(t => Tuple.Create(t.Item1, true)), interfaceMissing).ToList()
                                            )
                                        , type));
        }