public MethodCallExpression(Expression objectExpression,
    String method,
    Expression arguments) 
{
        this(objectExpression,new ConstantExpression(method),arguments);
}

 public MethodCallExpression(Expression objectExpression,
    Expression method,
    Expression arguments) 
{
        this.objectExpression = objectExpression;
        this.method = method;
        this.arguments = arguments;
        //TODO: set correct type here
        // if setting type and a methodcall is the last expression in a method,
        // then the method will return null if the method itself is not void too!
        // (in bytecode after call: aconst_null, areturn)
        this.setType(ClassHelper.DYNAMIC_TYPE);
        this.setImplicitThis(true);
}

 public Expression getArguments() 
{
        return arguments;
}

 public MetaMethod getMetaMethod() 
{
          
        return null;
}

 public Expression getMethod() 
{
        return method;
}

 public String getMethodAsString() 
{
        if (! (method instanceof ConstantExpression)) return null;
        ConstantExpression constant = (ConstantExpression) method;
        return constant.getText();
}

This method returns the method name as String if it is no dynamic calculated method name, but a constant.

 public Expression getObjectExpression() 
{
        return objectExpression;
}

 public String getText() 
{
        return objectExpression.getText() + "." + method.getText() + arguments.getText();
}

 public boolean isImplicitThis() 
{
        return implicitThis;
}

 public boolean isSafe() 
{
        return safe;
}

 public boolean isSpreadSafe() 
{
        return spreadSafe;
}

 public  void setArguments(Expression arguments) 
{
      this.arguments = arguments;
}

 public  void setImplicitThis(boolean implicitThis) 
{
        this.implicitThis = implicitThis;
}

 public  void setMetaMethod(MetaMethod mmeth) 
{
        //this.metaMethod = mmeth;
        //super.setType(ClassHelper.make(mmeth.getReturnType()));
}

 public  void setMethod(Expression method) 
{
      this.method = method;
}

 public  void setObjectExpression(Expression objectExpression) 
{
      this.objectExpression = objectExpression;
}

 public  void setSafe(boolean safe) 
{
        this.safe = safe;
}

 public  void setSpreadSafe(boolean value) 
{
        spreadSafe = value;
}

 public String toString() 
{
        return super.toString()
            + "[object: "
            + objectExpression
            + " method: "
            + method
            + " arguments: "
            + arguments
            + "]";
}

 public Expression transformExpression(ExpressionTransformer transformer) 
{
        MethodCallExpression answer =
            new MethodCallExpression(transformer.transform(objectExpression), transformer.transform(method), transformer.transform(arguments));
        answer.setSafe(safe);
        answer.setSpreadSafe(spreadSafe);
        answer.setImplicitThis(implicitThis);
        answer.setSourcePosition(this);
        return answer;
}

 public  void visit(GroovyCodeVisitor visitor) 
{
        visitor.visitMethodCallExpression(this);
}