Description Michael Moser 2006-11-10 07:08:08 EST

While the eclipse JDT code formatter is definitely excellent and has gone a *long* way there are still a few things that I can not tweak to my liking, esp. re. line wrapping:

1.) Method arguments:

I still miss an option that allows me to wrap all but the first argument,
i.e. even if a line is too long I would like to see:

// max. length, say, here ---| 
    int someLongMethodName(int foo,  // (1)
                           boolean bar,  // (2)
                           someType yetAnotherArg) {
        ...
    }

Remarks:
(1) the 1st arg should always remain with the method name even if it exceeds 
    the max. line length
(2) all following lines are wrapped and "indented on column", again not 
    mattering whether they exceed the max. line length or not.

The closest approach I was able to so far yields:
----------
    ...
    int someLongMethodName(
                           int foo,
                           boolean bar,
                           someType yetAnotherArg) {
        ...
    }
    ...
----------
but I *hate* that linebreak for the first argument. The first arg. should remain on the same line!


Similar for the qualified method invocation. I don't see the point in the following formatting (which is what I get now):

----------
    ...
   // max. length, say, here ------------------| 
   someIdentifier(someArg).someFieldName
                                        .someMethodName(
                                                        foo, 
                                                        bar)
                                                            .otherMethod(arg0,
                                                                         arg1);
    ...
----------
                                                    

That should either be:
----------
    ...
   someIdentifier(someArgHere).someFieldName
                              .someMethodName(foo, 
                                              bar)
                              .otherMethod(arg0, arg1);
   ...
----------
   (i.e. indenting all on the first qualification-'.' and wrapping args if 
    necessary)

or:
----------
   ...
   someIdentifier(someArg).someFieldName.someMethodName(foo, 
                                                        bar).someMethod(arg0, 
                                                                        arg1);
   ...
----------
                                                            
   (i.e. ignoring the max. line length for the qualifications and only wrapping 
    the arguments, but those in the style described above).


Michael