Improving the source-code indentation in Wolfram Workbench

Question

One thing that I like about the more recent versions of the Mathematica front-end is that I think it does a good job indenting code. The language's functional nature, in my experience, leads to a lot of nesting, and the small indentation works well for this pupose. However, for some reason, the rules used for Wolfram Workbench (at least as of version 2.0) are evidently completely different, and the results look much worse. This can be helped somewhat by adjusting editor settings for Eclipse, but it still needs a lot of work. For example, here's a really silly approach for determining whether an integer is even or not, which I picked because it has a lot of indentation, as it's formatted in a Mathematica notebook:

Module[{even, odd, withoutLimit},
  even[0] = True;
  odd[0] = False;

  even[n_Integer] := odd[n - 1];
  odd[n_Integer] := even[n - 1];

  Attributes[withoutLimit] = {HoldFirst};
  withoutLimit[expr_] :=
   Block[{$IterationLimit = Infinity},
    expr];

  With[{test =
     Function[n,
      n >= 0]},
   Pillsy`EvenQ[n_Integer] := withoutLimit@even[n] /; test[n];
   Pillsy`EvenQ[n_Integer] := even[-n];

   Pillsy`OddQ[n_Integer] := withoutLimit@odd[n] /; test[n];
   Pillsy`OddQ[n_Integer] := odd[-n]]];

I find this quite readable. Here's the same code, copied into Workbench and formatted using its automatic source formatting (I added some whitespace between logically related definitions, which I'm used to doing manually):

Module[ {even, odd, withoutLimit},
  even[0] = True;
  odd[0] = False;

  even[n_Integer] :=
    odd[n - 1];
  odd[n_Integer] :=
    even[n - 1];

  Attributes[withoutLimit] = {HoldFirst};
  withoutLimit[expr_] :=
    Block[ {$IterationLimit = Infinity},
      expr
    ];

  With[ {test =
     Function[n,
      n >= 0]},

    Pillsy`EvenQ[n_Integer] :=
      withoutLimit@even[n] /; test[n];
    Pillsy`EvenQ[n_Integer] :=
      even[-n];

    Pillsy`OddQ[n_Integer] :=
      withoutLimit@odd[n] /; test[n];
    Pillsy`OddQ[n_Integer] :=
      odd[-n]
  ]
];

I'd like to make the second example look a lot more like the first example. In particular, the insistance that trailing square brackets from With, Module and Block should get lines all to themselves, like they're curly braces from C, makes me crazy.

Answer 1

This isn't a complete answer to your question, but it is worth noting that there are several preference panes in Wolfram Workbench that allow you to tweak the automatic formatting you get when you right-click (control-click) on some selected code and choose Source > Format. Both are accessed (under Windows) from the Window menu under the Preferences dialog.

The first one controls "Smart" formatting of Mathematica code. You can try tweaking some of these settings, but I haven't found one that stops the closing bracket being on a new line. I think this is pretty standard code formatting in other languages, so I'm not surprised it's enforced. This is not the default setting - I turned off the checkmarks for the curly braces. Turning them all off gave even worse results as far as I could tell. You could try turning off Smart Indenting altogether.

There is also a more general code formatting preference pane, which Mathematica mode also supports. I've reduced the indenting to three spaces instead of the usual four.