Long generic types cause excessive indentation

[peterbn]

Hi,

I was writing an interface that used some rather long generic type names, and when I ran it through google-java-format --aosp, I noticed that the type names got very uncomfortably formatted. I acknowledge that this is probably at the edge of what can be reasonably formatted, but I hope it can still be improved

I have provided an example input and the output I get below, as well as my suggestion for improvement.

The suggested points of improvement are:

• Do not break line after ? extends or ? super if the following TypeName< can also fit on the line.
• Use 4 spaces for each nested level of type. The first line is currently indented 16 spaces, which seems like a lot, and every following level uses 8 spaces.
• Don't indent the method name, but keep it at the same level as the type.

Input file

class Example {
      List<? extends Consumer<BiConsumer<@ThisIsAnIntDefAnnotationWithATooLongNameToFit Integer, Object>>>
      methodWithComplexReturnType1();

      List<? extends Consumer<BiConsumer<VeryLongAndComplicatedTypeName, OtherVeryLongAndComplicatedName>>>
      methodWithComplexReturnType2();

      List<Consumer<BiConsumer<VeryLongAndComplicatedTypeNameIsTooLong, OtherVeryLongAndComplicatedName>>>
      methodWithComplexReturnType3();

      GenericType<VeryLongAndComplicatedTypeNameThatBreaksTheLineLength, OtherVeryLongAndComplicatedName>
      methodWithComplexReturnType4();
}

Produced output by running google-java-format --aosp Example.java

class Example {
    List<
                    ? extends
                            Consumer<
                                    BiConsumer<
                                            @ThisIsAnIntDefAnnotationWithATooLongNameToFit Integer,
                                            Object>>>
            methodWithComplexReturnType1();

    List<
                    ? extends
                            Consumer<
                                    BiConsumer<
                                            VeryLongAndComplicatedTypeName,
                                            OtherVeryLongAndComplicatedName>>>
            methodWithComplexReturnType2();

    List<
                    Consumer<
                            BiConsumer<
                                    VeryLongAndComplicatedTypeNameIsTooLong,
                                    OtherVeryLongAndComplicatedName>>>
            methodWithComplexReturnType3();

    GenericType<
                    VeryLongAndComplicatedTypeNameThatBreaksTheLineLength,
                    OtherVeryLongAndComplicatedName>
            methodWithComplexReturnType4();
}

Suggested better output

class Example {
    List<
      ? extends Consumer<
          BiConsumer<
              @ThisIsAnIntDefAnnotationWithATooLongNameToFit Integer,
              Object>>>
    methodWithComplexReturnType1();

    List<
      ? extends Consumer<
          BiConsumer<
              VeryLongAndComplicatedTypeName,
              OtherVeryLongAndComplicatedName>>>
    methodWithComplexReturnType2();

    List<
        Consumer<
            BiConsumer<
                VeryLongAndComplicatedTypeNameIsTooLong,
                OtherVeryLongAndComplicatedName>>>
    methodWithComplexReturnType3();

    GenericType<
        VeryLongAndComplicatedTypeNameThatBreaksTheLineLength,
        OtherVeryLongAndComplicatedName>
    methodWithComplexReturnType4();
}

[cushon]

I agree this output uses a lot of indentation and whitespace, but I also agree this is getting towards the edge of what can reasonable be formatted as you say.

To explain a bit about how the formatter ends up with this output:

Do not break line after ? extends or ? super if the following TypeName< can also fit on the line.

For ? extends Consumer<...>, the formatter considers Consumer<...> to be at a lower syntactic level, so it tries to keep that construct together, at the expense of not putting ? extends Consumer< on the same line.

Use 4 spaces for each nested level of type. The first line is currently indented 16 spaces, which seems like a lot, and every following level uses 8 spaces.

The AOSP style guide specifies eight space indents for line wraps, and the formatter uses multiple continuation indents if necessary to differentiate between things that are at different syntactic levels.

Not using --aosp would reduce the level of indentation here, since Google Java Style uses 4 space continuation indents.

Don't indent the method name, but keep it at the same level as the type.

This is related to the decision to use indentation to differentiate between different syntactic levels, i.e.

    List<...>
        methodWithComplexReturnType1();

instead of:

    List<...>
    methodWithComplexReturnType1();