Less indentation for switch expression in assignment/initializer

[PhilippWendler]

I would like to suggest a different formatting of switch expressions that are used as right-hand side of an assignment: move the switch on the same line as the assignment and reduce indentation, in the same way as is done for switch expressions after a return. I am aware that this deviates slightly from the basic rules of Google Java Format, but I think this case is worth an exception.

Example code with current formatting:

  int returnSwitchExpression(int i) {
    return switch (i) {
      case 0 -> 1;
      case 1 -> 2;
      default -> 3;
    };
  }

  int assignSwitchExpression(int i) {
    int result =
        switch (i) {
          case 0 -> 1;
          case 1 -> 2;
          default -> 3;
        };
    return result;
  }

  int switchStatement(int i) {
    switch (i) {
      case 0 -> {
        return 1;
      }
      case 1 -> {
        return 2;
      }
      default -> {
        return 3;
      }
    }
  }

Proposed formatting:

  int assignSwitchExpression(int i) {
    int result = switch (i) {
      case 0 -> 1;
      case 1 -> 2;
      default -> 3;
    };
    return result;
  }

Note how the indentation of the switch cases in the assignment is currently different from both the return switch and the switch statement cases. Conceptually and syntactically the switch assignment is quite similar to the return switch, though, and it would make sense to let it look similarly. If the current formatting of the return switch case is considered fine, then certainly the proposed formatting should be similarly ok for readability and clarity of the code.

A concrete advantage of changing the formatting is that refactorings introduce less diff noise: both the a refactoring from a switch statement to a switch expression in an assigment as well as the refactoring of a switch expression out of a return into an assignment would keep the same indentation. Right now such refactorings necessarily change the indentation and typically lead to the complete switch being shown as changed in a diff. Note that for example Google Error Prone by default warns about such potential refactorings of switch statements into switch expressions, and Eclipse has a similar refactoring, so these are not that rare.

To be clear: I am not arguing for changing any formatting related to switch expressions in different places or those that are nested more deeply in an expression, my proposal is only about the case where the switch expression is the immediate right-hand-side child node of an assignment or variable declaration.

I also do not think that this would lead to problematic inconsistencies between switch expressions in assignments and initializers and those used elsewhere, because I would assume that switch expressions are almost exclusively used in the places discussed here and almost never nested more deeply. For example, the automated refactorings by Google Error Prone only introduce such basic cases and not deeper nestings.

Switch expressions are also syntactically special anyway compared to other expressions (e.g. because they always enforce some line breaks in the expression), so some inconsistency with regards to other expressions could be accepted.

So in summary I would think introducing this special case has a concrete benefit, no readability disadvantage, and does not introduce relevant inconsistencies.

[cushon]

There isn't a line break after return because that token is a fixed length. Theoretically a line break there could avoid going over the style guide's 100 character limit, but we didn't want formattings like:

return
    <expr>

... so the formatter just never emits line breaks there, and hopes for the best.

The difference with variable declarations is that they can be (potentially much) longer than return, so we sometimes need to support breaking there. And the fundamentally approach the formatter takes to line breaks to to break at the highest syntactic level first, so if it can break there, it will break there before it would break inside the initializer expression of the variable declaration.

I think there's a lot of overlap between having a general way to support the formatting that is desired here and the discussion in #19 (comment).

[PhilippWendler]

Sure, I am familiar with the general idea and concepts behind Google Java Format. I am trying to argue for this being one of the exceptions where a slight deviation from the rule is doable and worth it. I am in no way arguing for a bigger deviation from the rules or some "make it format the way I would like to see it" magical unicorn formatter.

And yes, if type variablenName = switch (expression) { is longer than 100 characters, the formatter should just add line breaks as usual.