//     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")]