Less indentation for switch expression in assignment/initializer

Inizia individuando la logica del formatter e i test esistenti per le switch expressions, quindi confronta gli esempi di assegnazione attuali e proposti in questo issue con la formattazione di return-switch. Il lavoro è completo quando le switch expressions che si trovano immediatamente a destra nelle assegnazioni e nelle dichiarazioni di variabili usano l'indentazione proposta senza modificare i casi di annidamento più profondo, con una copertura di regressione per gli esempi.

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.