public StatementsToInitializerConverter(RefactoringContext context)
 {
     this.context = context;
 }
Exemple #2
0
        static void AddImplementation(RefactoringContext context, TypeDeclaration result, IType guessedType)
        {
            foreach (var property in guessedType.GetProperties())
            {
                if (!property.IsAbstract)
                {
                    continue;
                }
                if (property.IsIndexer)
                {
                    var indexerDecl = new IndexerDeclaration {
                        ReturnType = context.CreateShortType(property.ReturnType),
                        Modifiers  = GetModifiers(property),
                        Name       = property.Name
                    };
                    indexerDecl.Parameters.AddRange(ConvertParameters(context, property.Parameters));
                    if (property.CanGet)
                    {
                        indexerDecl.Getter = new Accessor();
                    }
                    if (property.CanSet)
                    {
                        indexerDecl.Setter = new Accessor();
                    }
                    result.AddChild(indexerDecl, Roles.TypeMemberRole);
                    continue;
                }
                var propDecl = new PropertyDeclaration {
                    ReturnType = context.CreateShortType(property.ReturnType),
                    Modifiers  = GetModifiers(property),
                    Name       = property.Name
                };
                if (property.CanGet)
                {
                    propDecl.Getter = new Accessor();
                }
                if (property.CanSet)
                {
                    propDecl.Setter = new Accessor();
                }
                result.AddChild(propDecl, Roles.TypeMemberRole);
            }

            foreach (var method in guessedType.GetMethods())
            {
                if (!method.IsAbstract)
                {
                    continue;
                }
                var decl = new MethodDeclaration {
                    ReturnType = context.CreateShortType(method.ReturnType),
                    Modifiers  = GetModifiers(method),
                    Name       = method.Name,
                    Body       = new BlockStatement {
                        new ThrowStatement(new ObjectCreateExpression(context.CreateShortType("System", "NotImplementedException")))
                    }
                };
                decl.Parameters.AddRange(ConvertParameters(context, method.Parameters));
                result.AddChild(decl, Roles.TypeMemberRole);
            }

            foreach (var evt in guessedType.GetEvents())
            {
                if (!evt.IsAbstract)
                {
                    continue;
                }
                var decl = new EventDeclaration {
                    ReturnType = context.CreateShortType(evt.ReturnType),
                    Modifiers  = GetModifiers(evt),
                    Variables  =
                    {
                        new VariableInitializer {
                            Name = evt.Name
                        }
                    }
                };
                decl.Variables.Add(new VariableInitializer(evt.Name));
                result.AddChild(decl, Roles.TypeMemberRole);
            }
        }
 /// <summary>
 /// Gets the action for the specified ast node.
 /// </summary>
 /// <returns>
 /// The code action. May return <c>null</c>, if no action can be provided.
 /// </returns>
 /// <param name='context'>
 /// The refactoring conext.
 /// </param>
 /// <param name='node'>
 /// The AstNode it's ensured that the node is always != null, if called.
 /// </param>
 protected abstract CodeAction GetAction(RefactoringContext context, T node);