[TestMethod]
        public void UpdateNode()
        {
            string text = "class C { void M() { } }";
            var tree = SyntaxTree.ParseCompilationUnit(text);
            var root = (CompilationUnitSyntax)tree.Root;
            MethodDeclarationSyntax method = root
                .DescendentNodes()
                .OfType<MethodDeclarationSyntax>()
                .First();
            var newMethod = method.Update(
                method.Attributes,
                method.Modifiers,
                method.ReturnType,
                method.ExplicitInterfaceSpecifierOpt,
                Syntax.Identifier("NewMethodName"),
                method.TypeParameterListOpt,
                method.ParameterList,
                method.ConstraintClauses,
                method.BodyOpt,
                method.SemicolonTokenOpt);

            root = root.ReplaceNode(method, newMethod);
            tree = SyntaxTree.Create(tree.FileName, root, tree.Options);
            Assert.AreEqual("class C { void NewMethodName() { } }", tree.Text.GetText());
        }

MethodDeclarationSyntax  method = ...;
MethodDeclarationSyntax  newMethod  = new method {  Name = Syntax.Identifier("NewMethodName"); }

MethodDeclarationSyntax  newMethod  = new method {  Name = Syntax.Identifier("NewMethodName"); }

root = root.ReplaceNode(method, newMethod);

    //     Class which represents the syntax node for invocation expression.
    public sealed class InvocationExpressionSyntax : ExpressionSyntax
    {
        //     ArgumentListSyntax node representing the list of arguments of the invocation
        //     expression.
        public ArgumentListSyntax ArgumentList { get; }

        //     ExpressionSyntax node representing the expression part of the invocation.
        public ExpressionSyntax Expression { get; }

        public InvocationExpressionSyntax Update(ExpressionSyntax expression, ArgumentListSyntax argumentList);
    }

WH>root = root.ReplaceNode(method, newMethod);
WH>

public sealed class MemberAccessExpressionSyntax : ExpressionSyntax
{
  // Fields
  private ExpressionSyntax expression;
  private SimpleNameSyntax name;

  // Methods
  internal MemberAccessExpressionSyntax(SyntaxNode parent, SyntaxNode green, int position) : base(parent, green, position)
  {
  }

  internal override void Accept(SyntaxVisitor visitor)
  {
    visitor.VisitMemberAccessExpression(this);
  }

  internal override TResult Accept<TResult>(SyntaxVisitor<TResult> visitor)
  {
    return visitor.VisitMemberAccessExpression(this);
  }

  internal override SyntaxNode GetCachedSlot(int index)
  {
    switch (index)
    {
      case 0:
        return this.expression;

      case 2:
        return this.name;
    }
    return null;
  }

  internal override SyntaxNode GetNodeSlot(int index)
  {
    switch (index)
    {
      case 0:
        return base.GetRed<ExpressionSyntax>(ref this.expression, 0);

      case 2:
        return base.GetRed<SimpleNameSyntax>(ref this.name, 2);
    }
    return null;
  }

  public MemberAccessExpressionSyntax Update(ExpressionSyntax expression, SyntaxToken operatorToken, SimpleNameSyntax name)
  {
    if (((expression == this.Expression) && !(operatorToken != this.OperatorToken)) && (name == this.Name))
    {
      return this;
    }
    MemberAccessExpressionSyntax node = Syntax.MemberAccessExpression(base.Kind, expression, operatorToken, name);
    SyntaxAnnotation[] annotations = base.GetAnnotations();
    if ((annotations != null) && (annotations.Length > 0))
    {
      return node.WithAnnotations<MemberAccessExpressionSyntax>(annotations);
    }
    return node;
  }

  // Properties
  public ExpressionSyntax Expression
  {
    get
    {
      return base.GetRed<ExpressionSyntax>(ref this.expression, 0);
    }
  }

  public SimpleNameSyntax Name
  {
    get
    {
      return base.GetRed<SimpleNameSyntax>(ref this.name, 2);
    }
  }

  public SyntaxToken OperatorToken
  {
    get
    {
      return new SyntaxToken(this, (SyntaxToken) base.Green.GetSlot(1), this.GetChildPosition(1), base.GetChildIndex(1));
    }
  }
}

[TestMethod]
public void TransformTreeUsingSyntaxRewriter()
{
    string text = "class C { void M() { } int field; }";
    SyntaxTree tree = SyntaxTree.ParseCompilationUnit(text);
    SyntaxNode newRoot = new RemoveMethodsRewriter().Visit(tree.Root);
    Assert.AreEqual("class C { int field; }", newRoot.GetFullText());
}

[assembly: InternalsVisibleTo("Roslyn.Compilers.CSharp")]

var newMethod = method.Update( UpdateFlags.Attributes | UpdateFlags.Modifiers,
                attributes : myAttributes,
                modifiers : myModifiers);

var newMethod = method.Update(new MethodChanges { Attributes = myAttributes, Modifiers = myModifiers});